Overview - Ghost

GhostWorkspace

CI Pipeline Executions
- Filtered
Runs
Demo

Insights

Compare tasks
Analytics

Overview

Ghost

Loading workspace stats

Loading workspace insights...

Statistics interval

7 days30 days

Latest CI Pipeline Executions

Filter

Fuzzy

Sort by

© 2026 - Nx Cloud

Terms of Service Privacy Policy Changelog Status Docs Contact Nx Cloud Pricing Company @NxDevTools

GhostWorkspace

Agents
Replay
VCS
Self-Healing

Average execution time

9m 32s

1947 CI pipeline executions

Computation time saved

36d 15h

Cache hit rate

89%

Protect cache integrity with sandboxing

Time to Green

57m 11s

Was 1h 8m, improved by 16%

Succeeded
30886
32874374 Added @tryghost/memoize internal package no ref Several profile follow-ups memoize a pure derivation of an immutable input: compiled ICU messages by locale and text, parsed NQL filter trees, an Intl formatter per timezone. Each of those would otherwise grow its own Map, with its own (usually absent) bound. One small helper gives them the same bound and the same semantics: - memoize(compute, key, {max}) is a keyed memo backed by lru-cache, bounded at 500 entries by default. No TTL: entries are pure derivations of immutable inputs, so an entry is never stale, only evicted. - once(compute) computes on first call and returns the same value afterwards. Both carry reset(), and neither memoizes a throwing compute. Promises are stored like any other value; the helpers are meant for synchronous work. This is a memo helper, not a cache. Nothing derived from mutable state goes through it, because that needs real invalidation, which this deliberately does not have. The package holds no global state: no kill switch, no config key and no process-wide registry. A switch would double the code paths every consumer has to test, and a test that needs a clean memo can call its reset(). Nothing in core uses the package yet; consumers adopt it in follow-ups. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
by Austin Bur...
A
Succeeded
30886
80d5cdae Added a dependency-free core entry point to @tryghost/memoize no ref `memoize` statically imports lru-cache, and `once` has no use for it. Because both lived in one module, every `once` consumer loaded lru-cache — including boot.js, which calls `configure` before it has loaded anything else, so the package put lru-cache on Ghost's critical boot path for a helper that never touches it. lru-cache 11 is dual-format, so the ESM copy imported here is a separate instance from the CommonJS copy glob/path-scurry already loads; the cost was additive, not shared. Splitting `once` and `memoize` into their own modules, with the shared enabled flag and registry in a third, gives `@tryghost/memoize/core` (`once`, `configure`, `resetAll`) with nothing behind it. Measured from ghost/core in a cold process: 6.8ms and 183KB through /core against 27.9ms and 1094KB through the root. Splitting rather than lazily importing lru-cache inside `memoize` keeps both entry points free of top-level await, which require(esm) needs. Both entry points still share one enabled flag and one registry, so `configure` and `resetAll` cover every memo in the process whichever entry point created it. A test walks the module graph from src/core.ts and fails if anything reachable from it grows an external dependency. Core's boot and the test config helper both use /core. The shared registry holds weak references, pruned by a FinalizationRegistry, so a memo built in a factory or orphaned by a test module reload is collected with its cache rather than pinned for the life of the process; a collected memo can never be called, so resetAll() loses nothing by skipping it. Both helpers also drop a stored promise once it rejects, so an async compute is retried like a throwing sync one. configUtils.restore() re-applies the enabled flag from the restored config, so a test that boots with memoisation off doesn't leak that into the next one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K4KZATm5a3QU1xBM4Zntg4
by Claude
Succeeded
30886
250e50b8 Added a dependency-free core entry point to @tryghost/memoize no ref `memoize` statically imports lru-cache, and `once` has no use for it. Because both lived in one module, every `once` consumer loaded lru-cache — including boot.js, which calls `configure` before it has loaded anything else, so the package put lru-cache on Ghost's critical boot path for a helper that never touches it. lru-cache 11 is dual-format, so the ESM copy imported here is a separate instance from the CommonJS copy glob/path-scurry already loads; the cost was additive, not shared. Splitting `once` and `memoize` into their own modules, with the shared enabled flag and registry in a third, gives `@tryghost/memoize/core` (`once`, `configure`, `resetAll`) with nothing behind it. Measured from ghost/core in a cold process: 6.8ms and 183KB through /core against 27.9ms and 1094KB through the root. Splitting rather than lazily importing lru-cache inside `memoize` keeps both entry points free of top-level await, which require(esm) needs. Both entry points still share one enabled flag and one registry, so `configure` and `resetAll` cover every memo in the process whichever entry point created it. A test walks the module graph from src/core.ts and fails if anything reachable from it grows an external dependency. Core's boot and the test config helper both use /core. The shared registry holds weak references, pruned by a FinalizationRegistry, so a memo built in a factory or orphaned by a test module reload is collected with its cache rather than pinned for the life of the process; a collected memo can never be called, so resetAll() loses nothing by skipping it. Both helpers also drop a stored promise once it rejects, so an async compute is retried like a throwing sync one. configUtils.restore() re-applies the enabled flag from the restored config, so a test that boots with memoisation off doesn't leak that into the next one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K4KZATm5a3QU1xBM4Zntg4
by Claude
Succeeded
30886
5051627c Added a dependency-free once entry point to @tryghost/memoize no ref `memoize` statically imports lru-cache, and `once` has no use for it. Because both lived in one module, every `once` consumer loaded lru-cache — including boot.js, which calls `configure` before it has loaded anything else, so the package put lru-cache on Ghost's critical boot path for a helper that never touches it. lru-cache 11 is dual-format, so the ESM copy imported here is a separate instance from the CommonJS copy glob/path-scurry already loads; the cost was additive, not shared. Splitting `once` and `memoize` into their own modules, with the shared enabled flag and registry in a third, gives `@tryghost/memoize/once` with nothing behind it. Measured from ghost/core in a cold process: 6.8ms and 183KB through /once against 27.9ms and 1094KB through the root. Splitting rather than lazily importing lru-cache inside `memoize` keeps both entry points free of top-level await, which require(esm) needs. Both entry points still share one enabled flag and one registry, so `configure` and `resetAll` cover every memo in the process whichever entry point created it. A test walks the module graph from src/once.ts and fails if anything reachable from it grows an external dependency. Core's boot and the test config helper both use /once. The shared registry holds weak references, pruned by a FinalizationRegistry, so a memo built in a factory or orphaned by a test module reload is collected with its cache rather than pinned for the life of the process; a collected memo can never be called, so resetAll() loses nothing by skipping it. Both helpers also drop a stored promise once it rejects, so an async compute is retried like a throwing sync one. configUtils.restore() re-applies the enabled flag from the restored config, so a test that boots with memoisation off doesn't leak that into the next one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K4KZATm5a3QU1xBM4Zntg4
by Claude
Succeeded
30886
588c84dc Added a dependency-free once entry point to @tryghost/memoize no ref `memoize` statically imports lru-cache, and `once` has no use for it. Because both lived in one module, every `once` consumer loaded lru-cache — including boot.js, which calls `configure` before it has loaded anything else, so the package put lru-cache on Ghost's critical boot path for a helper that never touches it. lru-cache 11 is dual-format, so the ESM copy imported here is a separate instance from the CommonJS copy glob/path-scurry already loads; the cost was additive, not shared. Splitting `once` and `memoize` into their own modules, with the shared enabled flag and registry in a third, gives `@tryghost/memoize/once` with nothing behind it. Measured from ghost/core in a cold process: 6.8ms and 183KB through /once against 27.9ms and 1094KB through the root. Splitting rather than lazily importing lru-cache inside `memoize` keeps both entry points free of top-level await, which require(esm) needs. Both entry points still share one enabled flag and one registry, so `configure` and `resetAll` cover every memo in the process whichever entry point created it. A test walks the module graph from src/once.ts and fails if anything reachable from it grows an external dependency. Core's boot and the test config helper both use /once. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K4KZATm5a3QU1xBM4Zntg4
by Claude
Succeeded
30886
c3da528d Added a dependency-free once entry point to @tryghost/memoize no ref `memoize` statically imports lru-cache, and `once` has no use for it. Because both lived in one module, every `once` consumer loaded lru-cache — including boot.js, which calls `configure` before it has loaded anything else, so the package put lru-cache on Ghost's critical boot path for a helper that never touches it. lru-cache 11 is dual-format, so the ESM copy imported here is a separate instance from the CommonJS copy glob/path-scurry already loads; the cost was additive, not shared. Splitting `once` and `memoize` into their own modules, with the shared enabled flag and registry in a third, gives `@tryghost/memoize/once` with nothing behind it. Measured from ghost/core in a cold process: 6.8ms and 183KB through /once against 27.9ms and 1094KB through the root. Splitting rather than lazily importing lru-cache inside `memoize` keeps both entry points free of top-level await, which require(esm) needs. Both entry points still share one enabled flag and one registry, so `configure` and `resetAll` cover every memo in the process whichever entry point created it. A test walks the module graph from src/once.ts and fails if anything reachable from it grows an external dependency. Core's boot, the two lazy-require consumers and the test config helper all use /once; nothing in Ghost currently needs the root entry point. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K4KZATm5a3QU1xBM4Zntg4
by Claude
Failed
30886
2a1071fb Added @tryghost/memoize internal package no ref Several profile follow-ups memoise a pure derivation of an immutable input: compiled ICU messages by locale and text, locale candidate lists, parsed NQL filter trees, an Intl formatter per timezone, the parsed site URL, and lazily required modules on the request path. Each of those grows its own Map, with its own (usually absent) bound and no shared way to clear it. One helper gives them one bound, one kill switch and one test reset, and can later serve packages such as url-utils once they are pulled in-repo: - once(compute) computes on first call and returns the same value afterwards, which is the shape the lazy requires want. - memoize(compute, key, {max}) is a keyed memo backed by lru-cache, bounded at 500 entries by default and required to be finite. No TTL: entries are pure derivations of immutable inputs, so an entry is never stale, only evicted. Errors thrown by compute are not memoised. - configure({enabled}) is the kill switch, called once at boot from the new optimization.memoize config key; nothing else reads config from inside the package. - resetAll() clears every memo, called from configUtils.restore so tests that rewrite config or swap modules in the require cache are unaffected. This is a memo helper, not a cache. Nothing derived from the settings cache, the URL map or a database row goes through it — that is mutable state and needs real invalidation, which this deliberately does not have. The first two consumers are the lazy requires in link-replacer and generate-excerpt, which also prove the require(esm) path from CommonJS core. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01K4KZATm5a3QU1xBM4Zntg4
by Claude