@cursor/july 0.1.1 → 0.1.2

package/dist/internal/session-engine.js

@@ -26,8 +26,8 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { mergeABInstructions, resolveABMaxPlaygroundSessions, resolveABSplit, } from "../ab.js";
 import { slackThreadPermalink } from "../channels/slack/links.js";
 import { DIRECT_TOOL_CALL_CHANNEL_ID, isSymbolicConnectionTransport, } from "../types.js";
@@ -45,6 +45,7 @@ import { validateToolInput } from "./json-schema.js";
 import { McpHost } from "./mcp-host.js";
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
 import { SessionStore } from "./session-store.js";
+import { StorageCoordinator } from "./storage-coordinator.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
 import { buildAgentToolsCatalog, materializeWorkspace, writeWorkspaceFiles, } from "./workspace.js";
 export const HTTP_CHANNEL_ID = "http";
@@ -106,8 +107,10 @@ export class ApprovalInterruptedError extends Error {
 }
 export class SessionEngine {
     constructor(options) {
-        var _a;
-        var _b;
+        var _a, _b;
+        var _c, _d, _e;
+        /** In-flight lazy restores, deduped per channel + continuation key. */
+        this.restoreInFlight = new Map();
         this.channelsById = new Map();
         /** Sessions with a turn being admitted (before the run promise exists). */
         this.pendingTurns = new Set();
@@ -126,17 +129,29 @@ export class SessionEngine {
         this.project = options.project;
         this.stateRoot = options.stateRoot;
         this.runner = options.runner;
-        this.logger = (_b = options.logger) !== null && _b !== void 0 ? _b : (() => { });
+        this.logger = (_c = options.logger) !== null && _c !== void 0 ? _c : (() => { });
         this.sessions = new SessionStore(join(options.stateRoot, "sessions"));
         this.logs = new EventLogStore((sessionId) => this.sessions.eventFilePath(sessionId), (sessionId, error) => this.logger(`[agent-serve] failed to persist events for ${sessionId}: ${describeError(error)}`));
-        this.abCollector = new ABCollector(options.project.abs, this.logger, (sessionId) => __awaiter(this, void 0, void 0, function* () { return (yield this.logs.get(sessionId)).snapshot(0); }), Object.assign({ projectRoot: options.project.rootDir }, (((_a = options.project.abConfig) === null || _a === void 0 ? void 0 : _a.persistSamples) === undefined
-            ? {}
-            : { persistSamples: options.project.abConfig.persistSamples })));
+        this.storage =
+            options.project.storage === undefined
+                ? undefined
+                : new StorageCoordinator({
+                    definition: options.project.storage,
+                    agentName: options.project.name,
+                    projectRoot: options.project.rootDir,
+                    logger: this.logger,
+                });
+        // Domain-specific hooks win; the defineStorage sink is the fallback.
+        const persistSamples = (_d = (_a = options.project.abConfig) === null || _a === void 0 ? void 0 : _a.persistSamples) !== null && _d !== void 0 ? _d : (_b = this.storage) === null || _b === void 0 ? void 0 : _b.asABSamplePersistence();
+        this.abCollector = new ABCollector(options.project.abs, this.logger, (sessionId) => __awaiter(this, void 0, void 0, function* () { return (yield this.logs.get(sessionId)).snapshot(0); }), {
+            projectRoot: options.project.rootDir,
+            persistSamples,
+        });
         // Peer and Cursor-account transports are symbolic until the serve host
         // resolves them; the host-side MCP registry starts with the concrete
         // connections and gains the rest via setResolvedConnections.
         this.mcpHost = new McpHost(options.project.agent.connections.filter((connection) => !isSymbolicConnectionTransport(connection.transport)));
-        this.platforms = createHostPlatforms();
+        this.platforms = (_e = options.platforms) !== null && _e !== void 0 ? _e : createHostPlatforms();
         for (const channel of options.project.channels) {
             this.channelsById.set(channel.id, channel.definition);
         }
@@ -181,11 +196,17 @@ export class SessionEngine {
      */
     send(channelId_1, message_1) {
         return __awaiter(this, arguments, void 0, function* (channelId, message, options = {}) {
-            var _a, _b, _c;
-            const auth = (_a = options.auth) !== null && _a !== void 0 ? _a : null;
-            const existing = options.continuationToken === undefined
+            var _a;
+            var _b, _c, _d;
+            const auth = (_b = options.auth) !== null && _b !== void 0 ? _b : null;
+            let existing = options.continuationToken === undefined
                 ? undefined
                 : yield this.sessions.findByContinuation(channelId, options.continuationToken);
+            if (existing === undefined && options.continuationToken !== undefined) {
+                // Local miss: the session may live only in the storage sink (it
+                // fell outside the startup restore window, or restore is lazy-only).
+                existing = yield this.restoreSessionByContinuation(channelId, options.continuationToken);
+            }
             if (existing !== undefined) {
                 if (!samePrincipal(existing.auth, auth)) {
                     throw new SessionAuthError(existing.sessionId);
@@ -209,9 +230,9 @@ export class SessionEngine {
             let record = {
                 sessionId: newSessionId(),
                 channelId,
-                mode: (_b = options.mode) !== null && _b !== void 0 ? _b : "chat",
+                mode: (_c = options.mode) !== null && _c !== void 0 ? _c : "chat",
                 purpose,
-                continuationKey: (_c = options.continuationToken) !== null && _c !== void 0 ? _c : newContinuationKey(),
+                continuationKey: (_d = options.continuationToken) !== null && _d !== void 0 ? _d : newContinuationKey(),
                 auth,
                 title: options.title,
                 channelState,
@@ -224,6 +245,7 @@ export class SessionEngine {
                 updatedAt: now,
             };
             yield this.sessions.save(record);
+            (_a = this.storage) === null || _a === void 0 ? void 0 : _a.sessionRecord(record);
             yield this.appendEvent(record.sessionId, {
                 type: "session.started",
                 data: { channelId },
@@ -996,11 +1018,22 @@ export class SessionEngine {
     }
     queueDispatch(sessionId, event) {
         var _a;
-        const chain = (_a = this.dispatchChains.get(sessionId)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        var _b;
+        // Single funnel for both append paths (appendEvent + the held-log emit),
+        // so the storage sink sees every durable event exactly once.
+        (_a = this.storage) === null || _a === void 0 ? void 0 : _a.event(event);
+        const chain = (_b = this.dispatchChains.get(sessionId)) !== null && _b !== void 0 ? _b : Promise.resolve();
         const next = chain
             .then(() => this.dispatchEvent(sessionId, event))
             .catch((error) => {
             this.logger(`[agent-serve] event dispatch failed for ${sessionId}: ${describeError(error)}`);
+        })
+            .then(() => {
+            var _a;
+            // Turn-end flush happens here — after the boundary event's handlers
+            // and their record updates settled — so the persisted record carries
+            // the turn's final channel state and continuation token.
+            (_a = this.storage) === null || _a === void 0 ? void 0 : _a.eventDispatched(event);
         });
         this.dispatchChains.set(sessionId, next);
     }
@@ -1127,10 +1160,29 @@ export class SessionEngine {
      */
     abSnapshot(caller, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            var _b;
             const sessions = yield this.listSessions(caller, options);
             const abConfig = this.project.abConfig;
             const maxPlaygroundSessions = resolveABMaxPlaygroundSessions(abConfig === null || abConfig === void 0 ? void 0 : abConfig.maxPlaygroundSessions);
             const foldedSessions = sessions.slice(0, maxPlaygroundSessions);
+            // Backfill for a replacement host with nothing local to fold (e.g.
+            // lazy-only restore before any session resumed): serve the persisted
+            // aggregate instead of an empty surface. Gated on the host having no
+            // sessions AT ALL — the persisted snapshot spans every principal, so a
+            // caller who merely owns no sessions must not see it. Loaded once per
+            // process (playground polls this route ~every 4s); skip the persist
+            // side effect below — re-saving a restored snapshot would echo stale
+            // data back into the store.
+            if (foldedSessions.length === 0 &&
+                this.storage !== undefined &&
+                (yield this.sessions.list()).length === 0) {
+                (_b = this.restoredAbSnapshot) !== null && _b !== void 0 ? _b : (this.restoredAbSnapshot = this.storage.getLatestAbSnapshot());
+                const restoredSnapshot = yield this.restoredAbSnapshot;
+                if (restoredSnapshot !== undefined) {
+                    return restoredSnapshot;
+                }
+            }
             const snapshot = yield buildABSnapshot({
                 experiments: this.project.abs,
                 agentName: this.project.name,
@@ -1158,6 +1210,10 @@ export class SessionEngine {
                     this.logger(`[agent-serve] ab persistSnapshots.save threw: ${describeError(error)}`);
                 }
             }
+            else {
+                // defineStorage fallback (throttled inside the coordinator).
+                (_a = this.storage) === null || _a === void 0 ? void 0 : _a.abSnapshot(snapshot);
+            }
             return snapshot;
         });
     }
@@ -1275,12 +1331,14 @@ export class SessionEngine {
         var _a;
         const chain = (_a = this.updateChains.get(sessionId)) !== null && _a !== void 0 ? _a : Promise.resolve();
         const next = chain.then(() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
             const current = yield this.sessions.get(sessionId);
             if (current === undefined) {
                 throw new Error(`Session ${sessionId} not found`);
             }
             const updated = Object.assign(Object.assign({}, updater(current)), { updatedAt: new Date().toISOString() });
             yield this.sessions.save(updated);
+            (_a = this.storage) === null || _a === void 0 ? void 0 : _a.sessionRecord(updated);
             return updated;
         }));
         this.updateChains.set(sessionId, next.catch(() => { }));
@@ -1289,6 +1347,167 @@ export class SessionEngine {
     // ==========================================================================
     // Lifecycle
     // ==========================================================================
+    /**
+     * Restore sessions from the authored storage sink. Called once at
+     * serve start, before channels accept traffic: any persisted session
+     * missing from the local `--state-root` is materialized there — events
+     * as `events.ndjson`, record as `session.json` — after which every
+     * existing read path (continuation lookup, event replay/streams, A/B
+     * fold hydration) works unchanged. Local state always wins over the
+     * sink, so restarts on the same host are no-ops.
+     *
+     * Failures are logged and skipped; a broken store (including rows that
+     * violate the SessionRecord shape) never blocks serve start.
+     */
+    restoreStoredSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storage = this.storage;
+            if (storage === undefined || !storage.canBulkRestore) {
+                return;
+            }
+            const policy = storage.policy.restore;
+            if (policy === "off") {
+                return;
+            }
+            try {
+                yield this.runBulkRestore(storage, policy);
+            }
+            catch (error) {
+                this.logger(`[agent-serve] session restore failed: ${describeError(error)}`);
+            }
+        });
+    }
+    runBulkRestore(storage, policy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loaded = yield storage.listSessions();
+            // Guardrails on whatever the sink returned: drop invalid rows and
+            // sessions older than the age window, then restore newest-first under
+            // the count cap. Anything filtered out here stays reachable through
+            // the lazy continuation-lookup path.
+            const cutoff = Date.now() - policy.maxAgeMs;
+            const candidates = loaded
+                .map((record) => ({
+                record,
+                // Numeric timestamp for both the age filter and the sort; a
+                // non-string updatedAt (e.g. a raw DB Date from an untyped sink)
+                // parses to NaN and is dropped instead of crashing serve start.
+                updatedAt: typeof (record === null || record === void 0 ? void 0 : record.updatedAt) === "string"
+                    ? Date.parse(record.updatedAt)
+                    : Number.NaN,
+            }))
+                .filter(({ record, updatedAt }) => typeof (record === null || record === void 0 ? void 0 : record.sessionId) === "string" &&
+                record.sessionId !== "" &&
+                updatedAt >= cutoff)
+                .sort((a, b) => b.updatedAt - a.updatedAt)
+                .slice(0, policy.maxSessions)
+                .map(({ record }) => record);
+            let restored = 0;
+            let budget = policy.maxTotalBytes;
+            // Sink round trips dominate restore latency, so event streams are
+            // fetched with bounded parallelism; writes stay sequential, newest
+            // first, so the byte budget is enforced deterministically.
+            outer: for (let i = 0; i < candidates.length; i += RESTORE_FETCH_CONCURRENCY) {
+                const chunk = candidates.slice(i, i + RESTORE_FETCH_CONCURRENCY);
+                const fetched = yield Promise.all(chunk.map((record) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // Local state always wins over the sink.
+                        if ((yield this.sessions.get(record.sessionId)) !== undefined) {
+                            return undefined;
+                        }
+                        const events = yield storage.listSessionEvents(record.sessionId);
+                        return { record, events };
+                    }
+                    catch (error) {
+                        this.logger(`[agent-serve] failed to restore session ${record.sessionId}: ${describeError(error)}`);
+                        return undefined;
+                    }
+                })));
+                for (const item of fetched) {
+                    if (item === undefined) {
+                        continue;
+                    }
+                    const ndjson = eventsNdjson(item.events);
+                    // Budget is checked BEFORE anything is written: one oversized
+                    // session cannot blow past maxTotalBytes on disk. Skipped sessions
+                    // stay reachable through the lazy path.
+                    const bytes = Buffer.byteLength(JSON.stringify(item.record), "utf8") +
+                        (ndjson === undefined ? 0 : Buffer.byteLength(ndjson, "utf8"));
+                    if (bytes > budget) {
+                        this.logger(`[agent-serve] session restore stopped at the ${policy.maxTotalBytes}-byte budget after ${restored} session(s); remaining sessions restore lazily on resume`);
+                        break outer;
+                    }
+                    try {
+                        yield this.materializeSession(item.record, ndjson);
+                        budget -= bytes;
+                        restored += 1;
+                    }
+                    catch (error) {
+                        this.logger(`[agent-serve] failed to restore session ${item.record.sessionId}: ${describeError(error)}`);
+                    }
+                }
+            }
+            if (restored > 0) {
+                this.logger(`[agent-serve] restored ${restored} session(s) from storage`);
+            }
+        });
+    }
+    /**
+     * Lazy restore: a continuation lookup missed locally, so ask the sink
+     * for that one session and materialize it before resuming. Disk grows
+     * with sessions that are actually resumed, not with history.
+     *
+     * Concurrent misses for the same key (webhook redeliveries, retries)
+     * share one in-flight restore — a second materialization racing the
+     * first resumed turn could truncate events the turn already appended.
+     * Sink errors propagate and fail the send (see
+     * {@link StorageCoordinator.getSessionByContinuation}).
+     */
+    restoreSessionByContinuation(channelId, continuationKey) {
+        const storage = this.storage;
+        if (storage === undefined) {
+            return Promise.resolve(undefined);
+        }
+        const key = `${channelId}\u0000${continuationKey}`;
+        let pending = this.restoreInFlight.get(key);
+        if (pending === undefined) {
+            pending = this.loadAndMaterializeByContinuation(storage, channelId, continuationKey).finally(() => this.restoreInFlight.delete(key));
+            this.restoreInFlight.set(key, pending);
+        }
+        return pending;
+    }
+    loadAndMaterializeByContinuation(storage, channelId, continuationKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const record = yield storage.getSessionByContinuation(channelId, continuationKey);
+            if (record === undefined) {
+                // Definitive miss: the caller starts a fresh session under this token.
+                return undefined;
+            }
+            const local = yield this.sessions.get(record.sessionId);
+            if (local !== undefined) {
+                return local;
+            }
+            const events = yield storage.listSessionEvents(record.sessionId);
+            yield this.materializeSession(record, eventsNdjson(events));
+            this.logger(`[agent-serve] lazily restored session ${record.sessionId} from storage`);
+            return record;
+        });
+    }
+    /**
+     * Write one restored session to the local state root. Events land on
+     * disk before the record: a session becomes visible (and addressable via
+     * its continuation key) only with its full stream in place, and the
+     * lazily opened event log hydrates from this file.
+     */
+    materializeSession(record, eventsNdjson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (eventsNdjson !== undefined) {
+                const filePath = this.sessions.eventFilePath(record.sessionId);
+                yield mkdir(dirname(filePath), { recursive: true });
+                yield writeFile(filePath, eventsNdjson, "utf8");
+            }
+            yield this.sessions.save(record);
+        });
+    }
     trackBackground(promise) {
         this.backgroundWork.add(promise);
         void promise
@@ -1300,18 +1519,28 @@ export class SessionEngine {
     /** Drain running turns, dispatches, and pending writes, then dispose. */
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c;
             this.approvals.cancelAll("deny");
             yield Promise.allSettled([...this.activeTurns.values()]);
             yield Promise.allSettled([...this.backgroundWork]);
             yield Promise.allSettled([...this.dispatchChains.values()]);
             yield Promise.allSettled([...this.updateChains.values()]);
             yield this.logs.flushAll();
+            yield (_a = this.storage) === null || _a === void 0 ? void 0 : _a.close();
             yield this.mcpHost.close();
-            yield (_b = (_a = this.runner).dispose) === null || _b === void 0 ? void 0 : _b.call(_a);
+            yield (_c = (_b = this.runner).dispose) === null || _c === void 0 ? void 0 : _c.call(_b);
         });
     }
 }
+/** Parallel event-stream loads during the startup bulk restore. */
+const RESTORE_FETCH_CONCURRENCY = 8;
+/** NDJSON payload for a restored event stream; undefined when empty. */
+function eventsNdjson(events) {
+    if (events.length === 0) {
+        return undefined;
+    }
+    return `${events.map((event) => JSON.stringify(event)).join("\n")}\n`;
+}
 function subagentPrompt(subagent) {
     var _a;
     if (subagent.instructions !== undefined && subagent.instructions !== "") {

package/dist/internal/storage-coordinator.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Runtime for `defineStorage` (`agent/storage.ts`).
+ *
+ * The coordinator is the single funnel between the engine's hot paths and
+ * the author's key-value sink. The sink is four functions (`put` / `get` /
+ * `delete` / `list`); the coordinator owns everything else: it mints every
+ * key from the versioned scheme ({@link storageKeys}), coalesces
+ * session records and batches event chunks per turn (or debounce window),
+ * serializes delivery on one bounded queue per agent, and isolates
+ * failures — a throwing sink is logged and its write dropped; storage
+ * must never stall or fail a turn.
+ *
+ * Scaling shape: sessions, reminders, evals, and A/Bs all reduce to keyed
+ * puts on the same queue, so one author-owned sink covers every domain,
+ * and new domains are new key prefixes — not new config surface.
+ */
+import type { ABSamplePersistence } from "../ab.js";
+import type { EvalRunPersistence } from "../evals.js";
+import { type ResolvedStoragePolicy, type StorageContext, type StorageDefinition } from "../storage.js";
+import type { SessionEvent, SessionRecord } from "../types.js";
+import type { ABSnapshot } from "./ab-snapshot.js";
+import { type ReminderRecord } from "./reminder-store.js";
+export interface StorageCoordinatorOptions {
+    definition: StorageDefinition;
+    agentName: string;
+    projectRoot: string;
+    logger: (line: string) => void;
+}
+export declare class StorageCoordinator {
+    readonly policy: ResolvedStoragePolicy;
+    private readonly definition;
+    private readonly agentName;
+    private readonly projectRoot;
+    private readonly logger;
+    /** Per-session pending state (events + coalesced record). */
+    private readonly buffers;
+    /**
+     * Last continuation key written to the sink per session, so a token
+     * change emits a delete for the stale index entry alongside the new put.
+     */
+    private readonly continuationIndex;
+    /** Single delivery chain: writes reach the sink serialized, in order. */
+    private queue;
+    /** Ops on the queue not yet delivered (bounded by MAX_PENDING_OPS). */
+    private pending;
+    /** Ops dropped because the queue was full. */
+    private dropped;
+    private lastAbSnapshotAt;
+    private closed;
+    constructor(options: StorageCoordinatorOptions);
+    /** Durable session-record update (engine calls after every store save). */
+    sessionRecord(record: SessionRecord): void;
+    /** One appended session event (engine calls from its dispatch funnel). */
+    event(event: SessionEvent): void;
+    /**
+     * A boundary event's dispatch settled: channel/hook handlers ran and
+     * their record updates (channel state, continuation tokens) are
+     * buffered. This — not the append — is the turn-end flush point, so the
+     * persisted session record includes the boundary event's own handler
+     * mutations. Debounced batching intentionally ignores boundaries.
+     */
+    eventDispatched(event: SessionEvent): void;
+    /** Flush everything buffered for one session (ordered: events, record). */
+    flushSession(sessionId: string, reason?: StorageContext["reason"]): void;
+    /**
+     * Index maintenance for `continuation/{channelId}/{token}` → sessionId:
+     * put the current token, delete the previous one when it changed.
+     */
+    private continuationOps;
+    /** Whether the sink can serve the startup bulk restore (`list`). */
+    get canBulkRestore(): boolean;
+    /**
+     * Saved session records for this agent (startup restore). Errors are
+     * logged and read as "nothing saved" — a broken store must never block
+     * serve start.
+     */
+    listSessions(): Promise<SessionRecord[]>;
+    /**
+     * Saved event stream for one session: chunk values concatenated in key
+     * order (chunks are keyed by their first event's index, zero-padded, so
+     * ascending key order is append order). Errors read as an empty stream.
+     */
+    listSessionEvents(sessionId: string): Promise<SessionEvent[]>;
+    /**
+     * One saved session by channel continuation key (lazy restore). Unlike
+     * the startup reads, sink errors **propagate**: a failing store must
+     * fail the follow-up (which the caller can retry) rather than read as
+     * "unknown token" — that would mint a new session under the same
+     * continuation key and permanently shadow the real one on this host.
+     * A definitive miss (no index entry, or a write-only sink without
+     * `get`) resolves undefined.
+     */
+    getSessionByContinuation(channelId: string, continuationKey: string): Promise<SessionRecord | undefined>;
+    /**
+     * Mirror one reminder record (create / fire / cancel / disarm). Local
+     * disk under `--state-root/reminders` remains the live source of truth;
+     * this is the durable copy for host replacement.
+     */
+    reminder(record: ReminderRecord): void;
+    /**
+     * Saved reminder records for this agent (startup hydrate into local
+     * disk). Errors read as empty — same posture as session bulk restore.
+     */
+    listReminders(): Promise<ReminderRecord[]>;
+    /**
+     * Adapter for {@link EvalRunPersistence} so the playground eval store
+     * can fall back to this sink when `evals.config.ts` sets no
+     * `persistRuns`.
+     */
+    asEvalRunPersistence(): EvalRunPersistence;
+    /**
+     * Adapter for {@link ABSamplePersistence} so the AB collector can fall
+     * back to this sink when `ab.config.ts` sets no `persistSamples`.
+     */
+    asABSamplePersistence(): ABSamplePersistence;
+    /**
+     * Refresh the persisted aggregate A/B snapshot, throttled to once per
+     * {@link AB_SNAPSHOT_MIN_INTERVAL_MS} (the playground recomputes the
+     * fold on every `GET /v1/abs` poll).
+     */
+    abSnapshot(snapshot: ABSnapshot): void;
+    /** Latest persisted aggregate A/B snapshot; errors read as absent. */
+    getLatestAbSnapshot(): Promise<ABSnapshot | undefined>;
+    /**
+     * Flush all buffers and drain the queue, giving the sink at most
+     * {@link CLOSE_DRAIN_TIMEOUT_MS} — a hung sink must not stall shutdown
+     * past the pod grace period. Called from engine close.
+     */
+    close(): Promise<void>;
+    /** Pending deliveries (exposed for tests and drain instrumentation). */
+    whenIdle(): Promise<void>;
+    private buffer;
+    private armDebounce;
+    /** `list` wrapper for the startup reads: missing hook or throw ⇒ empty. */
+    private tryList;
+    private enqueue;
+    private context;
+}
+//# sourceMappingURL=storage-coordinator.d.ts.map

package/dist/internal/storage-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-coordinator.d.ts","sourceRoot":"","sources":["../../src/internal/storage-coordinator.ts"],"names":[],"mappings":"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"}