Skip to content

Repository navigation

fix(deps): update dependency zod to v4 - #1557

Closed
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/zod-4.x
Closed

fix(deps): update dependency zod to v4#1557
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/zod-4.x

Conversation

@renovate

@renovate renovate Bot commented Jul 31, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

ℹ️ Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package Change Age Confidence
zod (source) 3.24.2 → 4.6.4 age confidence

Release Notes

colinhacks/zod (zod)

v4.6.4

Compare Source

A patch on top of 4.6.3.

  • d6bc1e30 feat: add z.currencyCode() over a vendored ISO 4217 list, refreshed weekly by CI (#​6595)
  • ad32d751 perf: z.url() rejects an invalid URL with URL.canParse() instead of a throwing constructor, about 50x faster; fewer allocations on the validation path (#​6588)
  • 2bb08717 chore: re-pin the integration peers to the workspace zod after the 4.6.4 bump
  • f6e1701a chore(deps): bump next to 15.5.25 and vite to 7.3.6 (#​6153)

v4.6.3

Compare Source

A patch on top of 4.6.2.

  • 413cce9a fix(v4): make z.properties() a check again (#​6594) — removes the standalone z.properties() schema from 4.6.0; z.instanceof().properties() and .check(...z.properties()) are unchanged
  • 75d63ee1 docs: show only the .properties() method form in the 4.6 post
  • 46da9572 docs: match the error-message examples to what the parsers emit

v4.6.2

Compare Source

Commits:

v4.6.1

Compare Source

A patch on top of 4.6.0.

v4.6.0

Compare Source

Commits:

  • 908c9e1 fix(docs): retry the GitHub stars fetch and log the real status
  • 93186ca docs(wiki): drop the zod-compiler benchmark (#​6505)
  • 8ce9e8d feat(mini): publish Zod Mini as the standalone @​zod/mini package (#​6491)
  • 2956c4c chore(mini): sync @​zod/mini to 4.5.4
  • abd41ad docs(wiki): move plans and comparisons into a gitignored internal/ (#​6506)
  • 8106573 chore(docs): build with Turbopack
  • c7ec94d ci: check zod and @​zod/mini lockstep on npm after every publish (#​6507)
  • c46eeff chore: narrow blanket biome-ignore comments (#​6504)
  • a0898b4 ci: wait hours for npm to serve a publish, not ten minutes (#​6502)
  • 1c0bce0 docs: bring the 4.5 charts and worked examples into the docs pages
  • 70eb2c0 docs: drop the traits section and the compilation feature bullet
  • 43b9bfc docs: drop the bound-methods section from the Zod package page
  • cd4f9a6 perf(v4): report Standard Schema issues without constructing a ZodError (#​6509)
  • f3cb364 docs: surface the blog on the home page and in the sidebar
  • f3e7c72 fix(docs): render the docs 404 page inside the (doc) layout once
  • f412178 ci: publish @​zod/mini to JSR in lockstep with npm (#​6510)
  • 5ff9566 Stop re-exporting the compile internals from zod/v4/core (#​6511)
  • 40b4d0b fix(ci): read zod's latest version with npm view when picking the backfill dist-tag
  • a6b4939 Mark the compile internals @​internal instead of hiding them (#​6518)
  • 3195ed0 docs: label the memory chart like the compile chart
  • 8cd1250 docs: center the memory chart callout labels
  • ff56a55 docs: center the memory chart callout labels and pad them off the number
  • fb2fedf docs: tighten the memory chart callout, pad the canvas, say "less memory"
  • 93f3ab3 docs: replace the blog navbar's GitHub icon with a star-count pill
  • 7ae49d6 docs: drop the circle around the star pill's GitHub mark and center it on the pill's arc
  • b801439 bench: add typebox (compiled and dynamic) to the moltar cross-library harness
  • 1ec6b7c docs: add an RSS feed to the blog at /blog/rss.xml
  • 08ba069 perf(v4): read Luhn digits with charCodeAt instead of string indexing (#​6529)
  • 319f47f Emit a length-aware base64url pattern in toJSONSchema (#​6527)
  • a2a019a Accept enum-typed targets in z.toZod (#​6528)
  • 74f9a6d docs: drop the toZod enum block from basics and pin the page's curation rule in a comment
  • f83ab51 fix(v4): reject component-only strings from z.emoji() (#​6532)
  • 84dd3b0 perf: build literal and enum pattern regexes lazily (#​6531)
  • 0227e53 docs: bump the star pill's GitHub mark to 20px
  • 68a609a Widen literal inputs in property check types (#​6520)
  • 2ec972e refactor: collapse toZod's enum leaf normalizer to a dummy union (#​6533)
  • bc1157e docs: use a Response example for z.properties()
  • 07c43e2 Keep the runtime base64 regexes linear so composed parse paths cannot overflow (#​6534)
  • bec73be perf(v4): build the safeParse error on first read (#​6519)
  • bf99021 perf: move util.cached's accessor to a prototype (#​6537)
  • 69f2a7f Collapse toZod's normalizer and move its docs to the API reference (#​6539)
  • abfb389 feat(v4): make z.properties() a schema, and give z.instanceof() a .properties() method (#​6536)
  • 51caf01 refactor: collapse cachedInternal back into cached (#​6540)
  • 81ded99 perf: answer z.validate from the compiled fast path on invalid input (#​6538)
  • eca9687 fix(v4): enforce the six JSON Schema keywords fromJSONSchema silently dropped (#​6535)
  • 68aca3d docs: cover the 4.5 API surface that never made it into the reference
  • 18e71c7 Rename the JSON Schema process helper so bundler polyfills cannot collide (#​6541)
  • 90269c6 Keep a numeric TS enum's reverse-mapping keys out of .options (#​6542)
  • 4d73088 Release the parsed input once a failing safeParse builds its error (#​6543)
  • cafbee4 fix(v4): parse recursive schemas built by a factory (#​6530)
  • 62e6624 feat(v4): add .validate() and .validateAsync() to Zod Classic (#​6547)
  • 07917f4 test(v4): pin the lazy safeParse error's stack behavior (#​6548)
  • 764ac59 perf(v4): settle z.validate on the first failure in parse order (#​6544)
  • e760471 docs: attribute the compiled failure cost to the fallback, not the double pass
  • 5489a53 test(v4): pin the check-chain case that keeps compiled validate's definite guard (#​6551)
  • 7a00236 fix(v4): don't let format checks overwrite tighter min/max bounds (#​6553)
  • e4d67f3 Migrate development and CI to Nub (#​6562)
  • 6f04836 fix(v4): derive JSON Schema constraints by folding checks in the converter (#​6554)
  • 804e0f5 perf: seal the CommonJS exports so require("zod") stops reading through a getter (#​6564)
  • 741981f perf(compile): for-in record walk, cheaper issue finalization, and a generative compile differential (#​6567)
  • eb1c108 ci: release only on workflow_dispatch behind the npm environment (#​6569)
  • 277613a docs: move the release procedure to the maintainer-local notes
  • dcbcf05 fix(compile): unwind the doc indent when a child generator throws (#​6570)
  • e54716c docs(ecosystem): add @​apical-ts/craft (#​5946)
  • c5b9bcb bench: measure what a runtime island's leaked indent cost the generated source
  • 22bed61 feat(v4): add z.iban() string format with mod-97 checksum (#​6571)
  • 36f1796 fix(v4): stop the memoizer from pinning a finished parse (#​6572)
  • f7fd554 perf(v4): drop the lookaheads from the email regex (#​6573)
  • f9465d4 docs: reconcile the sponsor listings with active sponsorships (#​6576)
  • 213ee75 feat(compile): add z.withParser for externally generated parsers (#​6575)
  • 6de10dc docs: reconcile the sponsor listings against every active sponsorship (#​6579)
  • 661673a docs: make the 9thCO logo visible on the light theme
  • 1c51cbe 4.6.0
  • 3b15499 feat(lang): add Tajik (tg) locale
  • c532d76 test(locales): cover Tajik error branches
  • 574d480 fix(locales): clarify Tajik discriminator value message
  • dd9c36f fix(v4): defer recursive object index inference (#​6580)
  • b12aa52 fix: preserve unique tags with defaulted discriminators (#​6582)

v4.5.4

Compare Source

Commits:

v4.5.3

Compare Source

v4.5.2

Compare Source

Commits:

  • a354314 fix(docs): keep blog posts out of the docs collection (#​6484)
  • d378c42 ci: drop canary publishing from the release workflow (#​6487)
  • 212b941 fix(v4): let a prototype method getter answer a bare call so vi.spyOn works (#​6488)
  • e7576f5 docs(blog): let the page show through the navbar in dark mode (#​6489)
  • fedb06f fix(docs): match the blog TOC hover bar to the 2px active indicator
  • 6c932fc chore: bump devcontainer image to Node 24 (#​6470)
  • 6635d9d docs(blog): soften the "method memoization" attribution
  • 019ae29 fix(docs): drop ISR on the docs route so the home page hydrates
  • 652bb43 chore(docs): drop the scroll log from the route-change scroller
  • 571c8e8 fix(docs): render blog tabs with the stock fumadocs tab card
  • 9a193aa 4.5.2

v4.5.1

Compare Source

Commits:

  • 2e862db ci: gate the GitHub release and JSR publish on the version being live on npm
  • 8e03380 4.5.1

v4.5.0

Compare Source

Zod 4.5 is now available.

npm install zod@latest

At a glance:

z.compile()

You can now pre-compile any Zod schema using z.compile(schema). This dramatically speeds up parsing performance.

import * as z from "zod";

const Player = z.object({
  username: z.string(),
  bio: z.string(),
  xp: z.number()
});

const CompiledPlayer = z.compile(Player);

A compiled schema can be used exactly like an uncompiled one. There are no special rules around compiled schemas. They're just faster.

Player.parse({ ... });
CompiledPlayer.parse({ ... }); // ~2x faster

On objects, arrays, and unions, this speeds up parsing by a factor of ~3–7. More complex schemas stand to benefit more than simpler ones.

Time per parse on a shared nanosecond axis, standard parser as a gray bar with the compiled time as a blue bar inside it: an array of 10 objects 377 ns to 68 ns (5.5x), a 20-key object 301 ns to 38 ns (7.8x), an array of 10 strings 241 ns to 33 ns (7.3x), a union of 3 objects 190 ns to 36 ns (5.3x), a 3-element tuple 119 ns to 33 ns (3.6x), a 5-key strict object 117 ns to 32 ns (3.7x), a discriminated union 92 ns to 27 ns (3.4x), a 5-key object 76 ns to 28 ns (2.8x); up to 7.8x faster when compiled

Time per parse by schema type, standard parser vs compiled — lower is better (benchmark)

Below are the Moltar benchmark results comparing Zod (compiled and uncompiled) against the Moltar ParseSafe bench.

Bar chart of operations per second on the moltar benchmark fixture, parseSafe category: Zod 4 compiled 47.5M, typia 45.3M, Zod 4 11.6M, valibot 1.8M, effect 1.7M, Zod 3 1.2M, arktype 152k, yup 121k

Throughput on the moltar benchmark fixture (parseSafe: returns a new object with unknown keys stripped) — higher is better (benchmark)

And the equivalent results for the Moltar AssertLoose bench. Tested against the new z.validate(schema, input) function (detailed later in the post).

Bar chart of operations per second on the moltar benchmark fixture, assertLoose category: typia 74.9M, arktype 66.2M, Zod 4 compiled 60.6M, Zod 4 6.5M, valibot 1.9M, effect 1.7M, Zod 3 1.2M, yup 124k

Throughput on the moltar benchmark fixture (assertLoose: returns a boolean, unknown keys allowed) — higher is better (benchmark)

Zod's entire test suite runs twice—once normally and again with auto-compilation enabled globally—to ensure perfect fidelity.

How it works

Under the hood, z.compile() walks the entire schema once and produces a hyperoptimized snippet of flat, loop-free JavaScript that can validate inputs far faster than a standard runtime validator. This snippet can be executed via new Function() (effectively a more powerful eval) to serve as a fast-path validator. Schemas use this to "fast check" validity, falling back to the regular runtime logic on validation failure to provide granular error information.

Take this simple Point schema:

const Point = z.object({
  x: z.number(),
  y: z.number()
});

Here is the generated snippet for it:

const isPoint = new Function("input", `
  if (typeof input !== "object" || input === null) return false;
  if (typeof input.x !== "number") return false;
  if (typeof input.y !== "number") return false;
  return true;
`);

isPoint({ x: 1, y: 2 }); // true
isPoint({ x: "1" });     // false

For the large majority of inputs, the generated function validates the data with the fastest logic JavaScript can express: straight-line typeof checks and property reads, with no interpreter in between. When it can't handle an input, Zod falls back to the standard parser.

This is the function Zod generates for the Player schema above:

if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID;
const v0 = input["username"];
if (typeof v0 !== "string") return INVALID;
const v1 = input["bio"];
if (typeof v1 !== "string") return INVALID;
const v2 = input["xp"];
if (typeof v2 !== "number" || !Number.isFinite(v2)) return INVALID;
const v3 = { "username": v0, "bio": v1, "xp": v2 };
return v3;

Armed with the power of new Function(), this happens in-process at runtime. There is no need to integrate with your build system.

The compiled schema is purely additive on top of the existing schema. It tacks on the pre-compiled fast path for checking valid inputs. When invalid data is detected, it returns the INVALID symbol to signal that parsing should fall back to the uncompiled parser. This structurally prevents subtle deviations in error reporting between compiled and uncompiled variants.

import "zod/compile"

To compile every schema in an application, import zod/compile once at the top of your entry point. Every schema constructed after that import is automatically compiled the first time it's used to parse data.

import "zod/compile"; // must come before modules that define schemas
import * as z from "zod";

const schema = z.object({ name: z.string() });
schema.parse({ name: "ok" }); // compiled on first parse

It also works as a Node.js CLI flag, which guarantees it runs before any module defines a schema:

node --import zod/compile app.js

Or set preload in bunfig.toml or nub.jsonc.

{
  "preload": ["zod/compile"]
}

All schemas benefit to varying degrees, though complex object/tuple/array schemas benefit more than simple scalar validators.

Read the docs, or the full technical writeup: Introducing z.compile()

z.creditCard()

A new string format: 12–19 digits, optionally separated by single spaces or hyphens, with a valid Luhn checksum. (#​5931)

z.creditCard().parse("4111 1111 1111 1111"); // ✅
z.creditCard().parse("4111 1111 1111 1112"); // ❌ bad checksum

z.properties()

The multi-property counterpart to z.property(). (#​5912)

const httpsUrl = z.instanceof(URL).check(
  ...z.properties({
    protocol: z.literal("https:" as string),
    hostname: z.string().regex(z.regexes.domain),
  })
);

httpsUrl.parse(new URL("https://example.com")); // ✅
httpsUrl.parse(new URL("http://localhost")); // ❌ protocol

z.deepPartial()

Back in functional form after being removed as a method in Zod 4. (#​5928)

const Post = z.object({
  title: z.string(),
  author: z.object({ name: z.string(), email: z.string() }),
});

const PartialPost = z.deepPartial(Post);
type PartialPost = z.output<typeof PartialPost>;
// => { title?: string; author?: { name?: string; email?: string } }

PartialPost.parse({ author: {} }); // ✅

The result is still a ZodObject, so .shape and .extend() keep working.

.exactPartial()

Like .partial(), but wraps each field in z.exactOptional() instead of z.optional(): keys may be omitted, but an explicit undefined is rejected. This matches TypeScript's Partial<> under exactOptionalPropertyTypes. (#​6065)

const Recipe = z.object({ title: z.string(), servings: z.number() });

const PartialRecipe = Recipe.exactPartial();
PartialRecipe.parse({});                    // ✅
PartialRecipe.parse({ title: undefined });  // ❌

In Zod Mini it's a top-level function: z.exactPartial(Recipe).

z.validate()

Standalone boolean validation, in Zod, Zod Mini, and Zod Core. It answers "is this input valid?" without constructing a ZodError, which makes rejection cheap: on invalid input it is up to 16x faster than .safeParse().success. The return type is a guard on the schema's input type, and z.validateAsync() covers schemas with async refinements. (#​6471)

z.validate(z.string(), "hi"); // true
z.validate(z.string(), 42);   // false

z.input() / z.output()

Project a schema onto its input or output side. Useful for validating the two halves of a codec independently. (#​5928)

const isoDate = z.codec(z.iso.datetime(), z.date(), {
  decode: (s) => new Date(s),
  encode: (d) => d.toISOString(),
});

const Event = z.object({ name: z.string(), at: isoDate });

z.input(Event).parse({ name: "launch", at: "2024-01-01T00:00:00Z" }); // ✅
z.output(Event).parse({ name: "launch", at: new Date() });            // ✅

This is a no-op on schemas not containing codecs/pipes.

z.toZod<T>()

A utility to define a Zod schema that agrees exactly with a static type, often one that is handwritten or externally defined. (#​5913)

type Player = { username: string; xp: number };

const Player = z.toZod<Player>()(
  z.object({
    username: z.string(),
    xp: z.number(),
  })
);

Player.shape.username; // ZodString — the schema is returned unchanged

z.getDiscriminatedOption()

Extract a discriminated union member by discriminator value. (#​5947)

const Fruit = z.object({ type: z.literal("fruit"), seeds: z.boolean() });
const Veg = z.object({ type: z.literal("vegetable"), leafy: z.boolean() });
const Produce = z.discriminatedUnion("type", [Fruit, Veg]);

z.getDiscriminatedOption(Produce, "fruit"); // typeof Fruit
z.getDiscriminatedOption(Produce, "meat");  // ❌ TypeScript error

Cyclical inputs

Zod recursive schemas now support cyclical data. For bundle size reasons, Zod Mini requires you to register a memoizer explicitly. (#​6387, #​6482)

Zod

const Category = z.object({
  name: z.string(),
  get subcategories() {
    return z.array(Category);
  },
});

const input: any = { name: "root", subcategories: [] };
input.subcategories.push(input);

const result = Category.parse(input);
result.subcategories[0] === result; // true

Zod Mini

// register a memoizer before defining any schemas
z.config({ memoizer: z.memoizer() });

const result = Category.parse(input);
result.subcategories[0] === result; // true

9x reduction in schema memory footprint

In Zod 4.4 a bare z.string() retained 7.5kb of heap. In Zod 4.5 it retains 784 bytes.

Bar chart of heap retained by one schema instance, zod 4.4.3 versus 4.5: a 10-key object 82.0kb to 11.0kb, a union 17.5kb to 2.13kb, z.string().min(1) 16.7kb to 3.37kb, a record 16.4kb to 2.64kb, z.string().optional() 12.6kb to 1.50kb, an array of strings 11.2kb to 1.93kb, z.string() 7.53kb to 784b, z.number() 4.44kb to 706b. Up to 9.8x smaller than 4.4.3.

Retained heap per schema instance, Zod 4.4.3 vs 4.5 (benchmark)

In Zod 4.4 and earlier, all schema methods were automatically bound to the instance itself. This allowed users to pluck methods from schemas without causing issues due to this-binding.

const { parse } = z.string();

parse("some data");

A consequence of this is that each bound method allocates space on the heap; method implementations are not shared across all instances via prototype, as you'd expect. Zod 4.5 implements a method memoization pattern that avoids allocating bound methods until they are actually accessed.

Read the deep dive: Reducing Zod's memory footprint by an order of magnitude

Faster failures

Zod .parse()/.safeParse() instantiates a JavaScript Error, which captures a stack trace. In the case of validation failures, this is often much slower than the parsing logic itself. When using .safeParse(), Zod no longer captures this stack trace, speeding up failure-path parses by a factor of ~7.5x. (#​6316, #​6450)

const result = Player.safeParse({ username: 42, bio: "hello", xp: 12 });
result.success; // false — ~7.5x faster than Zod 4.4
Bar chart of time per failing safeParse: zod 4.4 at 6.3 microseconds, zod 4.5 at 840 nanoseconds — 7.6x faster

Player schema (benchmark)

Symbol keys in z.object()

A shape can now declare a symbol key. TypeScript tracks it: a const symbol infers as unique symbol, so z.infer makes the key required and checks its value type. Undeclared symbol keys are still ignored. (#​6448)

const TAG = Symbol("tag");
const schema = z.object({ name: z.string(), [TAG]: z.number() });

schema.parse({ name: "alice", [TAG]: 42 }); // ✅ { name: "alice", [TAG]: 42 }
schema.safeParse({ name: "alice" });        // ❌ the symbol key is required

Bug fixes

All of these fix soundness issues, so a schema that relied on the old behavior may now reject input it used to accept.

⚠️ z.iso.datetime() requires seconds

RFC 3339 mandates seconds. z.iso.datetime() and z.iso.datetime({ offset: true }) no longer accept minute-precision input like 2020-01-01T06:15Z. local: true still admits 2020-01-01T06:15, since an unqualified datetime is outside RFC 3339 either way. (#​6457)

z.iso.datetime().parse("2020-01-01T06:15:00Z"); // ✅
z.iso.datetime().parse("2020-01-01T06:15Z");    // ❌ was accepted in 4.4

To accept both forms, union the two precisions:

z.union([z.iso.datetime(), z.iso.datetime({ precision: -1 })]);
⚠️ String length counts code points

.min(), .max(), and .length() counted UTF-16 code units, so z.string().max(5) rejected five emoji. They now count Unicode code points, which is what every non-JS consumer of a length bound does (Postgres, MySQL, Go, Python, and the maxLength that z.toJSONSchema() emits). .max() only loosens; .min() and .length() tighten for astral input. Graphemes are unchanged — a ZWJ sequence is still several code points. (#​6441)

z.string().max(5).parse("😀😀😀😀😀"); // was too_big, now passes
z.string().min(5).parse("😀😀😀");     // was fine, now too_small

Closes #​3355.

⚠️ Record keys and intersections match TypeScript

A record's key schema now governs only the keys that match it, the way TypeScript treats an index signature. Intersecting an object with a pattern-keyed record no longer rejects the object's own keys. (#​6412)

z.object({ name: z.string() })
  .and(z.record(z.string().regex(/^S_/), z.string()))
  .parse({ name: "a", S_a: "s" });
// 4.4: throws invalid_key on "name"
// 4.5: { name: "a", S_a: "s" }

Separately, an unrecognized_keys issue no longer aborts the schema it came from, so a strict object with an extra key and a bad value now reports both issues instead of just the first. Closes #​2200, #​2573, #​4017, #​5663.

⚠️ __proto__ is always stripped

Object and record parsers now drop a __proto__ key whether it comes from the input, is declared by the schema, or is produced by a record key transform. A key that a record's key schema normalizes to __proto__ is dropped too. .strict() reports an own __proto__ input key as unrecognized_keys instead of silently swallowing it. Error formatters and both JSON Schema converters use own-property writes so a toString or constructor path segment can't walk onto Object.prototype (#​6213, #​6367, #​6346). (#​6386, #​6354, #​6355, #​6221)

⚠️ Stricter string formats
  • z.ipv6() validated by handing the string to new URL(), which let ::@1\ and ::1\n through. It now checks the address alphabet directly (#​6442).
  • z.ulid() restricts the first character to 0–7; anything higher overflows the 48-bit timestamp. A fixture that doesn't start with a real timestamp, such as one with a leading letter, is now rejected (#​6095).
  • z.httpUrl() enforces the RFC 1035 length limits on the host, matching z.hostname() (#​6035).
  • z.emoji() no longer backtracks exponentially on a failed match (#​6347).
  • z.string().includes(sub, { position: N }) emits a JSON Schema pattern that allows at least N leading characters, matching String.prototype.includes (#​6024).

Commits

Zod 4.5 rolls up 155 commits. Thanks to everyone who contributed: @​dokson, @​deepshekhardas, @​zirkelc, @​francisjohnjohnston-web, @​MerlijnW70, @​codinsonn, @​oimo23, @​JSap0914, @​zelinewang, @​abhishek-chaudhary2003, @​spokodev, @​Mohammad-Faiz-Cloud-Engineer, @​hamed-bavar, @​MGPOCKY, @​ChiChuRita, @​dinwwwh, @​thristhart, @​tsmartin9, @​vedanshshetti, @​belicam, @​frastefanini, @​andersk, @​musaddiq-rafi, @​tachmyratsaparmyradov, @​arvindfroi, @​KUMachine, @​spidersouris, @​catdalfonso, @​mneetika, @​gwagjiug, @​MahinAnowar, @​MaksZhukov, @​emmayusufu, @​agcty, @​devareddy05, @​Vish05, @​yamcodes, @​mattiasahlsen, @​samchungy, @​ozzyfromspace, @​udohjeremiah, @​patrickwehbe, @​gajus, @​Harm-Nullix, @​thwbh, @​IdanGonen, @​irfanfandi, @​JuerGenie, @​marcalexiei, @​itsahmedbilal, @​DucMinhNe, @​meliharik.

❗ Important

✂ PR body was truncated to here.

Configuration

📅 Schedule: (UTC)

  • Branch creation
    • At any time (no schedule defined)
  • Automerge
    • At any time (no schedule defined)

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@socket-security

socket-security Bot commented Jul 31, 2026 •
edited
Loading

Copy link
Copy Markdown

Review the following changes in direct dependencies. Learn more about Socket for GitHub.

Diff Package Supply Chain
Security		 Vulnerability Quality Maintenance License
Updatednpm/​zod@​3.24.2 ⏵ 4.6.410010010096 +8100

View full report

@cloudflare-workers-and-pages

cloudflare-workers-and-pages Bot commented Jul 31, 2026 •
edited
Loading

Copy link
Copy Markdown

Deploying with  Cloudflare Workers  Cloudflare Workers

The latest updates on your project. Learn more about integrating Git with Workers.

Status Name Latest Commit Preview URL Updated (UTC)
✅ Deployment successful!
View logs		 ccusage-guide 4ae833f Commit Preview URL

Branch Preview URL		 Sep 16 2026, 04:58 PM

@pkg-pr-new

pkg-pr-new Bot commented Jul 31, 2026 •
edited
Loading

Copy link
Copy Markdown

Open in StackBlitz

ccusage

npx https://pkg.pr.new/ccusage@1557

@ccusage/ccusage-darwin-arm64

npx https://pkg.pr.new/@ccusage/ccusage-darwin-arm64@1557

@ccusage/ccusage-darwin-x64

npx https://pkg.pr.new/@ccusage/ccusage-darwin-x64@1557

@ccusage/ccusage-linux-arm64

npx https://pkg.pr.new/@ccusage/ccusage-linux-arm64@1557

@ccusage/ccusage-linux-x64

npx https://pkg.pr.new/@ccusage/ccusage-linux-x64@1557

@ccusage/ccusage-win32-x64

npx https://pkg.pr.new/@ccusage/ccusage-win32-x64@1557

commit: 4ae833f

@github-actions

github-actions Bot commented Jul 31, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: bd0c4e9c89d7
Base SHA: e93a1faf0dc1

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 334.2ms 3.01 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 319.7ms 3.15 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 115.2ms 8.74 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 91.6ms 10.99 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 27.7ms 24.6ms 1.13x 55.25 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
claude session --offline --json 0.00 MiB 24.5ms 25.7ms 0.95x 55.00 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
codex daily --offline --json 0.00 MiB 24.3ms 25.1ms 0.97x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 23.3ms 22.9ms 1.02x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 359.6ms 339.0ms 1.06x 960.59 MiB 926.59 MiB 0.96x 2.80 GiB/s 2.97 GiB/s
codex --offline --json 1.01 GiB 116.7ms 126.9ms 0.92x 410.91 MiB 402.91 MiB 0.98x 8.63 GiB/s 7.94 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.28 KiB 4194.28 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Jul 31, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: bd0c4e9c89d7
Base SHA: e93a1faf0dc1

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 346.6ms 2.90 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 329.1ms 3.06 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 114.8ms 8.77 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 94.6ms 10.65 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 29.9ms 5.5ms 5.43x 55.25 MiB 12.45 MiB 0.23x 0.05 MiB/s 0.28 MiB/s
claude session --offline --json 0.00 MiB 28.9ms 4.6ms 6.33x 55.25 MiB 12.46 MiB 0.23x 0.05 MiB/s 0.34 MiB/s
codex daily --offline --json 0.00 MiB 25.5ms 2.3ms 10.97x 55.00 MiB 10.45 MiB 0.19x 0.03 MiB/s 0.37 MiB/s
codex session --offline --json 0.00 MiB 24.6ms 2.4ms 10.34x 55.25 MiB 10.45 MiB 0.19x 0.03 MiB/s 0.36 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 363.4ms 332.9ms 1.09x 958.59 MiB 1002.60 MiB 1.05x 2.77 GiB/s 3.02 GiB/s
codex --offline --json 1.01 GiB 118.2ms 95.0ms 1.24x 422.91 MiB 416.91 MiB 0.99x 8.52 GiB/s 10.59 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.28 KiB 4194.28 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from bd0c4e9 to 19795b8 Compare August 1, 2026 01:17
@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 19795b81d45c
Base SHA: 735d55f9d792

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 341.2ms 2.95 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 320.2ms 3.14 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 117.7ms 8.55 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 95.0ms 10.60 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 27.6ms 4.9ms 5.69x 55.00 MiB 12.46 MiB 0.23x 0.06 MiB/s 0.32 MiB/s
claude session --offline --json 0.00 MiB 23.7ms 2.9ms 8.32x 55.00 MiB 12.46 MiB 0.23x 0.07 MiB/s 0.54 MiB/s
codex daily --offline --json 0.00 MiB 23.4ms 2.5ms 9.48x 55.00 MiB 10.45 MiB 0.19x 0.04 MiB/s 0.35 MiB/s
codex session --offline --json 0.00 MiB 24.7ms 2.4ms 10.43x 55.00 MiB 10.45 MiB 0.19x 0.03 MiB/s 0.36 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 356.1ms 314.8ms 1.13x 948.59 MiB 948.59 MiB 1.00x 2.83 GiB/s 3.20 GiB/s
codex --offline --json 1.01 GiB 116.1ms 95.0ms 1.22x 418.91 MiB 400.91 MiB 0.96x 8.67 GiB/s 10.60 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 19795b81d45c
Base SHA: 735d55f9d792

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 335.3ms 3.00 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 308.9ms 3.26 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 123.5ms 8.15 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 114.4ms 8.80 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 27.3ms 28.4ms 0.96x 55.00 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.05 MiB/s
claude session --offline --json 0.00 MiB 25.2ms 24.2ms 1.04x 55.00 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
codex daily --offline --json 0.00 MiB 22.9ms 23.9ms 0.96x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
codex session --offline --json 0.00 MiB 23.8ms 24.6ms 0.97x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 352.5ms 322.1ms 1.09x 956.59 MiB 960.59 MiB 1.00x 2.86 GiB/s 3.13 GiB/s
codex --offline --json 1.01 GiB 114.3ms 114.0ms 1.00x 400.90 MiB 424.91 MiB 1.06x 8.81 GiB/s 8.83 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from 19795b8 to 7618c13 Compare August 1, 2026 09:15
@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 7618c1371a41
Base SHA: da32a706a362

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 337.6ms 2.98 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 300.4ms 3.35 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 120.7ms 8.34 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 91.5ms 11.01 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 28.4ms 5.2ms 5.50x 54.75 MiB 12.46 MiB 0.23x 0.05 MiB/s 0.30 MiB/s
claude session --offline --json 0.00 MiB 22.5ms 3.4ms 6.57x 55.00 MiB 12.45 MiB 0.23x 0.07 MiB/s 0.45 MiB/s
codex daily --offline --json 0.00 MiB 23.0ms 2.3ms 9.83x 55.00 MiB 10.45 MiB 0.19x 0.04 MiB/s 0.37 MiB/s
codex session --offline --json 0.00 MiB 25.1ms 2.2ms 11.18x 55.00 MiB 10.45 MiB 0.19x 0.03 MiB/s 0.38 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 356.5ms 335.5ms 1.06x 956.59 MiB 948.59 MiB 0.99x 2.82 GiB/s 3.00 GiB/s
codex --offline --json 1.01 GiB 119.5ms 94.4ms 1.27x 402.91 MiB 410.91 MiB 1.02x 8.43 GiB/s 10.67 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 7618c1371a41
Base SHA: da32a706a362

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 337.1ms 2.99 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 318.3ms 3.16 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 113.2ms 8.90 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 90.0ms 11.19 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 28.5ms 28.3ms 1.01x 55.00 MiB 55.00 MiB 1.00x 0.05 MiB/s 0.05 MiB/s
claude session --offline --json 0.00 MiB 23.7ms 25.1ms 0.95x 55.00 MiB 55.00 MiB 1.00x 0.07 MiB/s 0.06 MiB/s
codex daily --offline --json 0.00 MiB 23.0ms 24.6ms 0.93x 54.75 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 26.3ms 25.8ms 1.02x 55.00 MiB 55.00 MiB 1.00x 0.03 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 366.3ms 355.7ms 1.03x 954.59 MiB 962.60 MiB 1.01x 2.75 GiB/s 2.83 GiB/s
codex --offline --json 1.01 GiB 116.2ms 118.4ms 0.98x 414.91 MiB 418.91 MiB 1.01x 8.66 GiB/s 8.50 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from 7618c13 to db4dbc9 Compare August 1, 2026 11:31
@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: db4dbc92b8c2
Base SHA: d426a9de9edf

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: d426a9de9edf

@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: db4dbc92b8c2
Base SHA: d426a9de9edf

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: d426a9de9edf

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from db4dbc9 to 45f3f13 Compare August 1, 2026 18:38
@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 45f3f13f989f
Base SHA: 7fcbda3f1a91

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: 7fcbda3f1a91

@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 45f3f13f989f
Base SHA: 7fcbda3f1a91

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: 7fcbda3f1a91

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from 45f3f13 to b7a2ab4 Compare August 1, 2026 22:33
@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: b7a2ab47a846
Base SHA: 11b68625ef8d

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 326.7ms 3.08 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 321.2ms 3.13 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 116.1ms 8.67 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 89.5ms 11.24 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 25.9ms 27.8ms 0.93x 55.25 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
claude session --offline --json 0.00 MiB 26.7ms 27.7ms 0.96x 55.00 MiB 54.75 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
codex daily --offline --json 0.00 MiB 23.8ms 22.1ms 1.08x 55.25 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
codex session --offline --json 0.00 MiB 23.5ms 22.2ms 1.06x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 357.2ms 339.3ms 1.05x 954.59 MiB 962.59 MiB 1.01x 2.82 GiB/s 2.97 GiB/s
codex --offline --json 1.01 GiB 115.3ms 120.4ms 0.96x 406.91 MiB 420.91 MiB 1.03x 8.73 GiB/s 8.36 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB -0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Aug 1, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: b7a2ab47a846
Base SHA: 11b68625ef8d

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 343.7ms 2.93 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 309.3ms 3.26 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 115.7ms 8.70 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 91.4ms 11.02 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 25.6ms 4.3ms 6.02x 55.00 MiB 12.45 MiB 0.23x 0.06 MiB/s 0.36 MiB/s
claude session --offline --json 0.00 MiB 23.3ms 4.5ms 5.18x 55.00 MiB 12.45 MiB 0.23x 0.07 MiB/s 0.34 MiB/s
codex daily --offline --json 0.00 MiB 24.2ms 2.4ms 10.01x 55.00 MiB 10.45 MiB 0.19x 0.04 MiB/s 0.35 MiB/s
codex session --offline --json 0.00 MiB 23.8ms 2.2ms 10.62x 55.00 MiB 10.45 MiB 0.19x 0.04 MiB/s 0.38 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 365.5ms 316.7ms 1.15x 952.59 MiB 962.59 MiB 1.01x 2.75 GiB/s 3.18 GiB/s
codex --offline --json 1.01 GiB 116.4ms 98.6ms 1.18x 406.91 MiB 408.91 MiB 1.00x 8.65 GiB/s 10.21 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB -0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from b7a2ab4 to b14135f Compare August 2, 2026 01:27
@github-actions

github-actions Bot commented Aug 2, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: b14135f3a379
Base SHA: 11bb17f23d27

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 336.1ms 3.00 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 314.9ms 3.20 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 114.2ms 8.82 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 92.4ms 10.89 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 28.2ms 5.4ms 5.21x 54.75 MiB 12.46 MiB 0.23x 0.05 MiB/s 0.29 MiB/s
claude session --offline --json 0.00 MiB 28.6ms 2.6ms 10.86x 55.00 MiB 12.45 MiB 0.23x 0.05 MiB/s 0.59 MiB/s
codex daily --offline --json 0.00 MiB 24.7ms 2.9ms 8.56x 55.00 MiB 10.45 MiB 0.19x 0.03 MiB/s 0.30 MiB/s
codex session --offline --json 0.00 MiB 23.1ms 2.3ms 10.02x 55.00 MiB 10.45 MiB 0.19x 0.04 MiB/s 0.37 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 366.3ms 316.1ms 1.16x 950.59 MiB 962.59 MiB 1.01x 2.75 GiB/s 3.19 GiB/s
codex --offline --json 1.01 GiB 118.4ms 93.5ms 1.27x 410.91 MiB 426.90 MiB 1.04x 8.51 GiB/s 10.76 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Aug 2, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: b14135f3a379
Base SHA: 11bb17f23d27

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 345.4ms 2.91 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 317.5ms 3.17 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 114.3ms 8.81 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 96.4ms 10.44 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 29.4ms 25.1ms 1.17x 55.00 MiB 54.75 MiB 1.00x 0.05 MiB/s 0.06 MiB/s
claude session --offline --json 0.00 MiB 26.1ms 25.4ms 1.03x 55.00 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
codex daily --offline --json 0.00 MiB 23.9ms 24.9ms 0.96x 55.00 MiB 55.25 MiB 1.00x 0.04 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 23.2ms 24.7ms 0.94x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 355.7ms 353.2ms 1.01x 948.59 MiB 946.59 MiB 1.00x 2.83 GiB/s 2.85 GiB/s
codex --offline --json 1.01 GiB 115.7ms 118.8ms 0.97x 412.91 MiB 406.91 MiB 0.99x 8.70 GiB/s 8.48 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from b14135f to 51bb432 Compare August 2, 2026 06:19
@github-actions

github-actions Bot commented Aug 2, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 51bb432ed82a
Base SHA: eda5e50b5eeb

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 347.9ms 2.89 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 307.6ms 3.27 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 118.7ms 8.48 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 94.4ms 10.67 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 25.9ms 29.8ms 0.87x 55.00 MiB 55.25 MiB 1.00x 0.06 MiB/s 0.05 MiB/s
claude session --offline --json 0.00 MiB 27.4ms 25.7ms 1.07x 55.00 MiB 55.00 MiB 1.00x 0.06 MiB/s 0.06 MiB/s
codex daily --offline --json 0.00 MiB 24.0ms 23.6ms 1.02x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
codex session --offline --json 0.00 MiB 23.6ms 23.6ms 1.00x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 374.6ms 347.0ms 1.08x 950.59 MiB 944.59 MiB 0.99x 2.69 GiB/s 2.90 GiB/s
codex --offline --json 1.01 GiB 117.0ms 117.2ms 1.00x 410.91 MiB 414.91 MiB 1.01x 8.61 GiB/s 8.59 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Aug 2, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 51bb432ed82a
Base SHA: eda5e50b5eeb

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 339.0ms 2.97 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 308.3ms 3.27 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 114.6ms 8.78 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 96.6ms 10.42 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 28.8ms 5.7ms 5.03x 55.25 MiB 12.45 MiB 0.23x 0.05 MiB/s 0.27 MiB/s
claude session --offline --json 0.00 MiB 25.1ms 2.6ms 9.47x 54.75 MiB 12.46 MiB 0.23x 0.06 MiB/s 0.58 MiB/s
codex daily --offline --json 0.00 MiB 23.0ms 2.3ms 9.91x 55.00 MiB 10.46 MiB 0.19x 0.04 MiB/s 0.37 MiB/s
codex session --offline --json 0.00 MiB 24.1ms 2.3ms 10.60x 55.25 MiB 10.45 MiB 0.19x 0.04 MiB/s 0.38 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 347.7ms 332.2ms 1.05x 954.59 MiB 962.59 MiB 1.01x 2.90 GiB/s 3.03 GiB/s
codex --offline --json 1.01 GiB 119.9ms 96.1ms 1.25x 412.91 MiB 396.90 MiB 0.96x 8.39 GiB/s 10.48 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 19.09 KiB 19.09 KiB +0.00 KiB 1.00x
installed native package binary 4194.34 KiB 4194.34 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@renovate
renovate Bot force-pushed the renovate/zod-4.x branch from 51bb432 to 777d588 Compare August 3, 2026 07:12
@github-actions

github-actions Bot commented Sep 15, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 564d33028e4b
Base SHA: a4a31c373dc3

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 467.2ms 2.16 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 358.3ms 2.81 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 138.6ms 7.26 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 101.1ms 9.96 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 48.2ms 17.1ms 2.82x 55.25 MiB 20.71 MiB 0.37x 0.03 MiB/s 0.09 MiB/s
claude session --offline --json 0.00 MiB 41.1ms 9.5ms 4.35x 55.00 MiB 20.97 MiB 0.38x 0.04 MiB/s 0.16 MiB/s
codex daily --offline --json 0.00 MiB 49.9ms 14.4ms 3.47x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.06 MiB/s
codex session --offline --json 0.00 MiB 51.7ms 13.9ms 3.73x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.06 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 637.9ms 507.9ms 1.26x 966.86 MiB 934.85 MiB 0.97x 1.58 GiB/s 1.98 GiB/s
codex --offline --json 1.01 GiB 142.6ms 103.8ms 1.37x 465.18 MiB 443.17 MiB 0.95x 7.06 GiB/s 9.70 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4534.97 KiB 4534.97 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 15, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 564d33028e4b
Base SHA: a4a31c373dc3

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 634.3ms 1.59 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 504.1ms 2.00 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 173.6ms 5.80 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 134.3ms 7.49 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 41.4ms 63.2ms 0.66x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.02 MiB/s
claude session --offline --json 0.00 MiB 73.8ms 69.1ms 1.07x 55.25 MiB 54.75 MiB 0.99x 0.02 MiB/s 0.02 MiB/s
codex daily --offline --json 0.00 MiB 58.5ms 56.1ms 1.04x 55.00 MiB 55.25 MiB 1.00x 0.01 MiB/s 0.02 MiB/s
codex session --offline --json 0.00 MiB 59.8ms 56.9ms 1.05x 55.00 MiB 55.00 MiB 1.00x 0.01 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 605.3ms 608.1ms 1.00x 964.85 MiB 972.85 MiB 1.01x 1.66 GiB/s 1.66 GiB/s
codex --offline --json 1.01 GiB 230.2ms 255.8ms 0.90x 423.17 MiB 427.17 MiB 1.01x 4.37 GiB/s 3.94 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4534.97 KiB 4534.97 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 15, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 44ff80d5b9b3
Base SHA: a4a31c373dc3

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 386.1ms 2.61 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 345.9ms 2.91 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 137.2ms 7.34 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 125.2ms 8.04 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 55.8ms 17.5ms 3.20x 54.75 MiB 20.71 MiB 0.38x 0.03 MiB/s 0.09 MiB/s
claude session --offline --json 0.00 MiB 45.3ms 13.2ms 3.42x 55.00 MiB 20.97 MiB 0.38x 0.03 MiB/s 0.12 MiB/s
codex daily --offline --json 0.00 MiB 42.9ms 8.9ms 4.84x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.10 MiB/s
codex session --offline --json 0.00 MiB 32.1ms 8.3ms 3.87x 55.25 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.10 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 400.5ms 372.3ms 1.08x 970.86 MiB 948.86 MiB 0.98x 2.51 GiB/s 2.70 GiB/s
codex --offline --json 1.01 GiB 133.9ms 106.7ms 1.25x 441.18 MiB 445.17 MiB 1.01x 7.52 GiB/s 9.43 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4534.97 KiB 4534.97 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 15, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 44ff80d5b9b3
Base SHA: a4a31c373dc3

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 380.8ms 2.64 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 320.4ms 3.14 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 175.9ms 5.72 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 127.7ms 7.88 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 41.5ms 41.6ms 1.00x 55.00 MiB 55.25 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 42.4ms 40.3ms 1.05x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 35.4ms 38.3ms 0.92x 55.25 MiB 54.75 MiB 0.99x 0.02 MiB/s 0.02 MiB/s
codex session --offline --json 0.00 MiB 38.3ms 38.0ms 1.01x 55.25 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 394.6ms 355.9ms 1.11x 962.85 MiB 966.86 MiB 1.00x 2.55 GiB/s 2.83 GiB/s
codex --offline --json 1.01 GiB 170.9ms 154.8ms 1.10x 423.18 MiB 431.18 MiB 1.02x 5.89 GiB/s 6.50 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4534.97 KiB 4534.97 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 15, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 13bece881c70
Base SHA: d34194988f46

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 381.2ms 2.64 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 325.3ms 3.09 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 127.4ms 7.90 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 101.1ms 9.96 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 36.0ms 8.6ms 4.18x 55.25 MiB 20.71 MiB 0.37x 0.04 MiB/s 0.18 MiB/s
claude session --offline --json 0.00 MiB 35.5ms 9.0ms 3.96x 54.75 MiB 20.72 MiB 0.38x 0.04 MiB/s 0.17 MiB/s
codex daily --offline --json 0.00 MiB 30.0ms 8.0ms 3.73x 55.25 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.11 MiB/s
codex session --offline --json 0.00 MiB 32.9ms 8.3ms 3.95x 55.00 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.10 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 388.6ms 356.1ms 1.09x 962.86 MiB 966.86 MiB 1.00x 2.59 GiB/s 2.83 GiB/s
codex --offline --json 1.01 GiB 132.2ms 104.9ms 1.26x 445.18 MiB 431.18 MiB 0.97x 7.61 GiB/s 9.60 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4546.47 KiB 4546.47 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 15, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 13bece881c70
Base SHA: d34194988f46

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 371.0ms 2.71 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 338.4ms 2.98 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 126.3ms 7.97 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 98.9ms 10.18 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 49.3ms 42.8ms 1.15x 55.00 MiB 55.00 MiB 1.00x 0.03 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 45.5ms 37.0ms 1.23x 55.25 MiB 55.00 MiB 1.00x 0.03 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 41.5ms 37.3ms 1.11x 55.00 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.02 MiB/s
codex session --offline --json 0.00 MiB 34.3ms 36.5ms 0.94x 55.00 MiB 54.75 MiB 1.00x 0.03 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 478.9ms 541.8ms 0.88x 976.86 MiB 962.86 MiB 0.99x 2.10 GiB/s 1.86 GiB/s
codex --offline --json 1.01 GiB 126.4ms 131.8ms 0.96x 435.17 MiB 421.17 MiB 0.97x 7.97 GiB/s 7.64 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4546.47 KiB 4546.47 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 94044d461793
Base SHA: 9762e09ad950

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 356.8ms 2.82 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 303.8ms 3.31 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 141.4ms 7.12 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 111.4ms 9.04 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 45.2ms 38.7ms 1.17x 55.25 MiB 55.25 MiB 1.00x 0.03 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 38.9ms 36.8ms 1.06x 55.00 MiB 55.25 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 35.2ms 33.6ms 1.05x 55.00 MiB 55.25 MiB 1.00x 0.02 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 35.1ms 36.7ms 0.96x 55.00 MiB 55.25 MiB 1.00x 0.02 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 360.0ms 351.8ms 1.02x 992.86 MiB 962.85 MiB 0.97x 2.80 GiB/s 2.86 GiB/s
codex --offline --json 1.01 GiB 135.1ms 138.8ms 0.97x 423.17 MiB 439.17 MiB 1.04x 7.45 GiB/s 7.25 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4546.78 KiB 4546.78 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 94044d461793
Base SHA: 9762e09ad950

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 546.5ms 1.84 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 454.0ms 2.22 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 197.7ms 5.09 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 162.3ms 6.20 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 39.1ms 17.5ms 2.24x 55.00 MiB 20.71 MiB 0.38x 0.04 MiB/s 0.09 MiB/s
claude session --offline --json 0.00 MiB 40.4ms 10.9ms 3.71x 55.00 MiB 20.72 MiB 0.38x 0.04 MiB/s 0.14 MiB/s
codex daily --offline --json 0.00 MiB 53.5ms 13.7ms 3.90x 55.25 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.06 MiB/s
codex session --offline --json 0.00 MiB 47.3ms 14.5ms 3.27x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.06 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 534.7ms 391.6ms 1.37x 978.85 MiB 948.86 MiB 0.97x 1.88 GiB/s 2.57 GiB/s
codex --offline --json 1.01 GiB 183.3ms 147.0ms 1.25x 461.18 MiB 433.18 MiB 0.94x 5.49 GiB/s 6.85 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4546.78 KiB 4546.78 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 326dfbb84d70
Base SHA: 8dd19bb25bb9

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 358.9ms 2.80 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 351.8ms 2.86 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 150.6ms 6.69 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 115.1ms 8.74 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 46.8ms 44.3ms 1.05x 55.00 MiB 55.25 MiB 1.00x 0.03 MiB/s 0.03 MiB/s
claude session --offline --json 0.00 MiB 42.7ms 36.2ms 1.18x 55.25 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 40.2ms 33.0ms 1.22x 55.00 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 37.3ms 37.5ms 0.99x 54.75 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 376.5ms 327.4ms 1.15x 936.84 MiB 965.09 MiB 1.03x 2.67 GiB/s 3.08 GiB/s
codex --offline --json 1.01 GiB 154.4ms 148.3ms 1.04x 447.41 MiB 425.42 MiB 0.95x 6.52 GiB/s 6.79 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4568.72 KiB 4568.72 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 326dfbb84d70
Base SHA: 8dd19bb25bb9

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 412.1ms 2.44 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 384.4ms 2.62 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 129.4ms 7.78 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 104.8ms 9.61 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 48.2ms 17.9ms 2.69x 55.00 MiB 20.70 MiB 0.38x 0.03 MiB/s 0.09 MiB/s
claude session --offline --json 0.00 MiB 44.6ms 10.8ms 4.14x 55.00 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.14 MiB/s
codex daily --offline --json 0.00 MiB 39.1ms 10.6ms 3.71x 54.75 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.08 MiB/s
codex session --offline --json 0.00 MiB 37.3ms 10.1ms 3.69x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.08 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 457.3ms 386.9ms 1.18x 960.85 MiB 972.85 MiB 1.01x 2.20 GiB/s 2.60 GiB/s
codex --offline --json 1.01 GiB 128.7ms 110.2ms 1.17x 451.41 MiB 455.42 MiB 1.01x 7.82 GiB/s 9.14 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4568.72 KiB 4568.72 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: d51e29051752
Base SHA: 26fbf461edfd

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 571.2ms 1.76 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 516.0ms 1.95 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 172.2ms 5.85 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 151.1ms 6.66 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 41.4ms 15.4ms 2.68x 55.00 MiB 20.96 MiB 0.38x 0.04 MiB/s 0.10 MiB/s
claude session --offline --json 0.00 MiB 38.0ms 9.8ms 3.89x 55.00 MiB 20.96 MiB 0.38x 0.04 MiB/s 0.16 MiB/s
codex daily --offline --json 0.00 MiB 33.8ms 9.5ms 3.55x 55.25 MiB 20.95 MiB 0.38x 0.03 MiB/s 0.09 MiB/s
codex session --offline --json 0.00 MiB 31.8ms 15.6ms 2.04x 55.00 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.06 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 387.3ms 353.0ms 1.10x 945.09 MiB 975.09 MiB 1.03x 2.60 GiB/s 2.85 GiB/s
codex --offline --json 1.01 GiB 176.3ms 190.6ms 0.92x 443.42 MiB 419.41 MiB 0.95x 5.71 GiB/s 5.28 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4592.28 KiB 4592.28 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: d51e29051752
Base SHA: 26fbf461edfd

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 393.6ms 2.56 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 373.2ms 2.70 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 150.1ms 6.71 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 143.4ms 7.02 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 35.6ms 43.9ms 0.81x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 33.7ms 37.0ms 0.91x 55.00 MiB 55.00 MiB 1.00x 0.05 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 33.0ms 37.0ms 0.89x 55.25 MiB 55.25 MiB 1.00x 0.03 MiB/s 0.02 MiB/s
codex session --offline --json 0.00 MiB 32.1ms 33.7ms 0.95x 55.25 MiB 55.25 MiB 1.00x 0.03 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 437.8ms 472.2ms 0.93x 965.09 MiB 967.10 MiB 1.00x 2.30 GiB/s 2.13 GiB/s
codex --offline --json 1.01 GiB 135.7ms 142.9ms 0.95x 433.41 MiB 417.41 MiB 0.96x 7.42 GiB/s 7.05 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4592.28 KiB 4592.28 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 7f5ba1857377
Base SHA: ef300c97bc53

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: ef300c97bc53

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 7f5ba1857377
Base SHA: ef300c97bc53

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: ef300c97bc53

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 20a8f4562d53
Base SHA: ef300c97bc53

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: ef300c97bc53

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 20a8f4562d53
Base SHA: ef300c97bc53

Performance comparison skipped.

Base package URL was not ready before 300.000s. Fixture performance comparison requires a base package when --base-dir is not provided.

Base package: ef300c97bc53

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 97005f469f7a
Base SHA: 58bb4ca65356

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 438.7ms 2.29 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 350.9ms 2.87 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 136.2ms 7.39 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 106.7ms 9.44 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 52.6ms 45.3ms 1.16x 55.00 MiB 55.00 MiB 1.00x 0.03 MiB/s 0.03 MiB/s
claude session --offline --json 0.00 MiB 39.2ms 44.0ms 0.89x 54.75 MiB 55.25 MiB 1.01x 0.04 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 37.5ms 40.3ms 0.93x 54.75 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.02 MiB/s
codex session --offline --json 0.00 MiB 38.0ms 40.7ms 0.94x 55.00 MiB 55.25 MiB 1.00x 0.02 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 447.5ms 413.0ms 1.08x 959.09 MiB 973.09 MiB 1.01x 2.25 GiB/s 2.44 GiB/s
codex --offline --json 1.01 GiB 133.3ms 135.3ms 0.99x 429.41 MiB 435.41 MiB 1.01x 7.55 GiB/s 7.44 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4592.47 KiB 4592.47 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 97005f469f7a
Base SHA: 58bb4ca65356

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 523.0ms 1.92 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 485.4ms 2.07 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 180.9ms 5.57 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 149.1ms 6.75 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 43.2ms 17.2ms 2.51x 55.00 MiB 20.96 MiB 0.38x 0.04 MiB/s 0.09 MiB/s
claude session --offline --json 0.00 MiB 39.1ms 10.5ms 3.72x 55.50 MiB 20.95 MiB 0.38x 0.04 MiB/s 0.15 MiB/s
codex daily --offline --json 0.00 MiB 34.5ms 13.1ms 2.63x 55.25 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.07 MiB/s
codex session --offline --json 0.00 MiB 66.5ms 20.2ms 3.30x 55.00 MiB 20.95 MiB 0.38x 0.01 MiB/s 0.04 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 607.1ms 508.4ms 1.19x 963.10 MiB 969.09 MiB 1.01x 1.66 GiB/s 1.98 GiB/s
codex --offline --json 1.01 GiB 197.9ms 155.0ms 1.28x 423.41 MiB 419.41 MiB 0.99x 5.09 GiB/s 6.49 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4592.47 KiB 4592.47 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: cd1e6cec3e25
Base SHA: 5e88263ed3c1

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 497.4ms 2.02 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 444.8ms 2.26 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 173.5ms 5.80 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 145.0ms 6.94 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 38.6ms 34.0ms 1.13x 55.25 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.05 MiB/s
claude session --offline --json 0.00 MiB 37.1ms 34.0ms 1.09x 55.00 MiB 55.25 MiB 1.00x 0.04 MiB/s 0.05 MiB/s
codex daily --offline --json 0.00 MiB 35.1ms 32.7ms 1.07x 55.00 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 33.4ms 31.4ms 1.06x 55.25 MiB 54.75 MiB 0.99x 0.03 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 393.5ms 369.0ms 1.07x 929.09 MiB 967.10 MiB 1.04x 2.56 GiB/s 2.73 GiB/s
codex --offline --json 1.01 GiB 130.3ms 133.1ms 0.98x 443.42 MiB 425.42 MiB 0.96x 7.73 GiB/s 7.56 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB -0.00 KiB 1.00x
installed native package binary 4593.03 KiB 4593.03 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: cd1e6cec3e25
Base SHA: 5e88263ed3c1

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 383.0ms 2.63 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 333.7ms 3.02 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 131.0ms 7.68 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 106.5ms 9.45 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 55.2ms 23.7ms 2.32x 55.00 MiB 20.97 MiB 0.38x 0.03 MiB/s 0.07 MiB/s
claude session --offline --json 0.00 MiB 53.5ms 14.7ms 3.63x 55.00 MiB 20.97 MiB 0.38x 0.03 MiB/s 0.10 MiB/s
codex daily --offline --json 0.00 MiB 52.9ms 14.6ms 3.61x 54.75 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.06 MiB/s
codex session --offline --json 0.00 MiB 57.2ms 9.6ms 5.94x 55.00 MiB 20.96 MiB 0.38x 0.01 MiB/s 0.09 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 473.7ms 514.1ms 0.92x 959.11 MiB 964.85 MiB 1.01x 2.13 GiB/s 1.96 GiB/s
codex --offline --json 1.01 GiB 137.6ms 105.1ms 1.31x 433.41 MiB 427.42 MiB 0.99x 7.31 GiB/s 9.58 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB -0.00 KiB 1.00x
installed native package binary 4593.03 KiB 4593.03 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: f8a25eefd73c
Base SHA: 5e88263ed3c1

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 340.5ms 2.96 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 323.6ms 3.11 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 134.3ms 7.50 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 115.7ms 8.70 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 50.9ms 11.3ms 4.49x 55.25 MiB 20.97 MiB 0.38x 0.03 MiB/s 0.14 MiB/s
claude session --offline --json 0.00 MiB 40.8ms 10.6ms 3.84x 55.25 MiB 20.97 MiB 0.38x 0.04 MiB/s 0.15 MiB/s
codex daily --offline --json 0.00 MiB 38.4ms 11.0ms 3.50x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.08 MiB/s
codex session --offline --json 0.00 MiB 37.5ms 10.2ms 3.69x 55.25 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.08 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 373.3ms 330.1ms 1.13x 963.10 MiB 951.09 MiB 0.99x 2.70 GiB/s 3.05 GiB/s
codex --offline --json 1.01 GiB 142.2ms 121.3ms 1.17x 437.42 MiB 431.42 MiB 0.99x 7.08 GiB/s 8.30 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB -0.00 KiB 1.00x
installed native package binary 4593.03 KiB 4593.03 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: f8a25eefd73c
Base SHA: 5e88263ed3c1

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 379.5ms 2.65 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 347.9ms 2.89 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 127.1ms 7.92 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 103.3ms 9.75 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 41.1ms 35.8ms 1.15x 55.00 MiB 55.25 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 33.8ms 33.8ms 1.00x 55.00 MiB 55.00 MiB 1.00x 0.05 MiB/s 0.05 MiB/s
codex daily --offline --json 0.00 MiB 32.5ms 31.3ms 1.04x 55.00 MiB 54.75 MiB 1.00x 0.03 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 32.1ms 31.9ms 1.01x 55.00 MiB 55.25 MiB 1.00x 0.03 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 375.3ms 374.9ms 1.00x 981.11 MiB 965.10 MiB 0.98x 2.68 GiB/s 2.69 GiB/s
codex --offline --json 1.01 GiB 129.8ms 131.9ms 0.98x 453.42 MiB 427.43 MiB 0.94x 7.76 GiB/s 7.63 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB -0.00 KiB 1.00x
installed native package binary 4593.03 KiB 4593.03 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 2d0ace8b3b3f
Base SHA: 416af6e75a26

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 412.0ms 2.44 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 337.6ms 2.98 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 164.9ms 6.11 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 136.2ms 7.39 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 43.7ms 17.4ms 2.51x 54.75 MiB 20.96 MiB 0.38x 0.04 MiB/s 0.09 MiB/s
claude session --offline --json 0.00 MiB 42.2ms 12.2ms 3.46x 55.00 MiB 20.96 MiB 0.38x 0.04 MiB/s 0.13 MiB/s
codex daily --offline --json 0.00 MiB 35.8ms 11.7ms 3.06x 55.00 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.07 MiB/s
codex session --offline --json 0.00 MiB 38.9ms 10.0ms 3.88x 54.75 MiB 20.96 MiB 0.38x 0.02 MiB/s 0.09 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 430.0ms 359.9ms 1.19x 927.09 MiB 963.09 MiB 1.04x 2.34 GiB/s 2.80 GiB/s
codex --offline --json 1.01 GiB 197.0ms 127.8ms 1.54x 433.42 MiB 431.42 MiB 1.00x 5.11 GiB/s 7.88 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4596.59 KiB 4596.59 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 2d0ace8b3b3f
Base SHA: 416af6e75a26

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 373.5ms 2.70 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 365.3ms 2.76 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 128.6ms 7.83 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 108.6ms 9.27 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 40.9ms 34.7ms 1.18x 55.25 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 33.7ms 38.4ms 0.88x 55.25 MiB 55.00 MiB 1.00x 0.05 MiB/s 0.04 MiB/s
codex daily --offline --json 0.00 MiB 30.7ms 29.9ms 1.03x 55.00 MiB 55.00 MiB 1.00x 0.03 MiB/s 0.03 MiB/s
codex session --offline --json 0.00 MiB 30.8ms 30.6ms 1.01x 55.00 MiB 55.00 MiB 1.00x 0.03 MiB/s 0.03 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 402.8ms 372.5ms 1.08x 940.84 MiB 967.10 MiB 1.03x 2.50 GiB/s 2.70 GiB/s
codex --offline --json 1.01 GiB 127.8ms 126.9ms 1.01x 443.41 MiB 427.41 MiB 0.96x 7.87 GiB/s 7.94 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4596.59 KiB 4596.59 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 4ae833f51274
Base SHA: 4be84d63273b

This compares the PR package against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 419.4ms 2.40 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 371.3ms 2.71 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 136.1ms 7.39 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 111.2ms 9.05 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 37.3ms 36.1ms 1.03x 54.75 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.04 MiB/s
claude session --offline --json 0.00 MiB 35.3ms 54.6ms 0.65x 55.00 MiB 55.00 MiB 1.00x 0.04 MiB/s 0.03 MiB/s
codex daily --offline --json 0.00 MiB 37.7ms 37.8ms 1.00x 55.00 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.02 MiB/s
codex session --offline --json 0.00 MiB 35.2ms 37.4ms 0.94x 55.00 MiB 55.00 MiB 1.00x 0.02 MiB/s 0.02 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published ccusage package from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 410.5ms 437.9ms 0.94x 970.85 MiB 969.10 MiB 1.00x 2.45 GiB/s 2.30 GiB/s
codex --offline --json 1.01 GiB 137.7ms 140.1ms 0.98x 445.41 MiB 431.41 MiB 0.97x 7.31 GiB/s 7.19 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4596.66 KiB 4596.66 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@github-actions

github-actions Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor

ccusage performance comparison

PR SHA: 4ae833f51274
Base SHA: 4be84d63273b

This compares the Rust PR release binary against the configured base package on the same CI runner.

Package runtime diagnostics

Compares the PR package wrapper, the installed native optional dependency binary, and the workspace release binary on the same large fixture. This identifies whether slow package results come from JavaScript wrapper overhead, the published native binary build, or the Rust core itself.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
All rows run --offline --json, measured by hyperfine with 0 warmups and 1 runs. This isolates wrapper overhead from the installed native optional dependency and the workspace release binary built on the runner.

Command Runtime Input Median Throughput Samples
claude --offline --json Package wrapper 1.01 GiB 430.8ms 2.34 GiB/s 1
claude --offline --json Installed native binary 1.01 GiB 375.6ms 2.68 GiB/s 1
codex --offline --json Package wrapper 1.01 GiB 136.7ms 7.37 GiB/s 1
codex --offline --json Installed native binary 1.01 GiB 111.4ms 9.03 GiB/s 1

Committed fixture performance

Committed small fixtures for stable PR-to-PR feedback and explicit Claude/Codex command coverage.

Fixtures: Claude apps/ccusage/test/fixtures/claude (0.00 MiB, 2 files), Codex apps/ccusage/test/fixtures/codex (0.00 MiB, 1 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 2 warmups and 7 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude daily --offline --json 0.00 MiB 47.8ms 18.4ms 2.60x 55.00 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.08 MiB/s
claude session --offline --json 0.00 MiB 42.6ms 13.2ms 3.22x 55.00 MiB 20.96 MiB 0.38x 0.04 MiB/s 0.12 MiB/s
codex daily --offline --json 0.00 MiB 33.3ms 9.9ms 3.37x 55.00 MiB 20.96 MiB 0.38x 0.03 MiB/s 0.09 MiB/s
codex session --offline --json 0.00 MiB 31.6ms 9.7ms 3.25x 55.00 MiB 20.95 MiB 0.38x 0.03 MiB/s 0.09 MiB/s

Large real-world-shaped fixture performance

Generated fixtures shaped from aggregate local log statistics: thousands of JSONL files, many small sessions, and a long tail of larger sessions. No real prompts, paths, or outputs are stored in the fixtures.

Fixtures: Claude /home/runner/_work/_temp/ccusage-large-fixture (1.01 GiB, 2597 files), Codex /home/runner/_work/_temp/ccusage-large-codex-fixture (1.01 GiB, 2597 files)
Base runs the published ccusage package from pkg.pr.new, installed before measurement; PR runs the published native ccusage binary from pkg.pr.new, installed before measurement. Both run --offline --json, measured by hyperfine with 0 warmups and 1 runs.
Peak RSS is measured separately with /usr/bin/time using 1 runs. Lower RSS ratios are better.

Command Input Base median PR median PR vs base Base peak RSS PR peak RSS PR/base RSS Base throughput PR throughput
claude --offline --json 1.01 GiB 434.1ms 391.7ms 1.11x 972.85 MiB 960.85 MiB 0.99x 2.32 GiB/s 2.57 GiB/s
codex --offline --json 1.01 GiB 178.6ms 119.7ms 1.49x 435.39 MiB 445.42 MiB 1.02x 5.64 GiB/s 8.41 GiB/s

Artifact size

Artifact Base PR Delta Ratio
packed ccusage-*.tgz 20.21 KiB 20.21 KiB +0.00 KiB 1.00x
installed native package binary 4596.66 KiB 4596.66 KiB +0.00 KiB 1.00x

Lower medians and smaller artifacts are better. CI runner noise still applies; use same-run ratios as directional PR feedback, not release guarantees.

@ryoppippi

ryoppippi commented Sep 16, 2026

Copy link
Copy Markdown
Member

Closing because models-dev-gen dependencies intentionally match the pinned models.dev Bun lock. The pinned upstream revision still uses Zod 3.24.2, so updating only this repository would break dependency parity and generated-output reproducibility. Renovate can propose the update again when the pinned upstream dependency changes.

@renovate

renovate Bot commented Sep 16, 2026

Copy link
Copy Markdown
Contributor Author

Renovate Ignore Notification

Because you closed this PR without merging, Renovate will ignore this update. You will not get PRs for any future 4.x releases. But if you manually upgrade to 4.x then Renovate will re-enable minor and patch updates automatically.

If you accidentally closed this PR, or if you changed your mind: rename this PR to get a fresh replacement PR.

@ryoppippi ryoppippi mentioned this pull request Oct 18, 2026
Merged
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@renovate-approve renovate-approve[bot] renovate-approve[bot] approved these changes

Assignees

No one assigned

Labels

dependencies renovate

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

1 participant

@ryoppippi