@sekiban/dcb-runtime 0.2.0

package/dist/tagstate/TagStateDurableObject.js

@@ -0,0 +1,499 @@
+import { assertSortableUniqueId, compareSortableUniqueId } from "../allocator/SortableUniqueId";
+import { projectionEventFromTagEvent, } from "../projection/ProjectorRegistry";
+import { scopeIdFor } from "../scope/ScopeName";
+/** The fixed bounded source page used by both normal delta and replay. */
+export const TAG_STATE_SOURCE_PAGE_LIMIT = 64;
+// A deployed Worker has one composed domain registry. The public Worker
+// factories install that exact registry before any request can reach a
+// TagStateDO. A global Symbol makes the slot common to the entrypoint bundle
+// and this package module, rather than silently falling back when tooling
+// loads them through distinct module URLs.
+const TAG_STATE_REGISTRY_SLOT = Symbol.for("sekiban.dcb.tagstate.projector-registry.v1");
+function configuredProjectorRegistry() {
+    return globalThis[TAG_STATE_REGISTRY_SLOT];
+}
+export function configureTagStateProjectorRegistry(registry) {
+    const target = globalThis;
+    if (registry === undefined) {
+        delete target[TAG_STATE_REGISTRY_SLOT];
+        return;
+    }
+    target[TAG_STATE_REGISTRY_SLOT] = registry;
+}
+class TagStateIdentityConflict extends Error {
+    constructor() {
+        super("TagState Durable Object identity changed");
+        this.name = "TagStateIdentityConflict";
+    }
+}
+class TagStateUnknownProjector extends Error {
+    constructor() {
+        super("TagState projector is no longer registered");
+        this.name = "TagStateUnknownProjector";
+    }
+}
+class TagStateRegistryFailure extends Error {
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : String(cause));
+        this.name = "TagStateRegistryFailure";
+    }
+}
+class TagStateSourceFailure extends Error {
+    status;
+    constructor(status, cause) {
+        super(cause instanceof Error ? cause.message : String(cause));
+        this.status = status;
+        this.name = "TagStateSourceFailure";
+    }
+}
+class TagStateCacheCorruption extends Error {
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : String(cause));
+        this.name = "TagStateCacheCorruption";
+    }
+}
+class TagStateCheckpointFault extends Error {
+    constructor() {
+        super("G46 checkpoint fault");
+        this.name = "TagStateCheckpointFault";
+    }
+}
+function json(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+function error(status, code, message) {
+    return json({ code, error: message }, status);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function sqlString(value, column) {
+    if (typeof value !== "string")
+        throw new TagStateCacheCorruption(new Error(`TagState SQL ${column} is not a string`));
+    return value;
+}
+function sqlNullableString(value, column) {
+    if (value === null || value === undefined)
+        return null;
+    return sqlString(value, column);
+}
+function parseIdentity(value) {
+    if (!isObject(value) || !isNonEmptyString(value.serviceId) || !isNonEmptyString(value.tag) || !isNonEmptyString(value.projectorId)) {
+        return undefined;
+    }
+    return { serviceId: value.serviceId, tag: value.tag, projectorId: value.projectorId };
+}
+function initializeTagStateSchema(sql) {
+    sql.exec(`
+    CREATE TABLE IF NOT EXISTS tag_state_identity (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      service_id TEXT NOT NULL,
+      tag TEXT NOT NULL,
+      projector_id TEXT NOT NULL,
+      UNIQUE (service_id, tag, projector_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS tag_state_cache (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      phase TEXT NOT NULL CHECK (phase IN ('READY', 'REBUILDING')),
+      projector_version TEXT,
+      state_json TEXT,
+      last_suid TEXT NOT NULL,
+      target_projector_version TEXT,
+      frozen_through TEXT,
+      replay_cursor TEXT,
+      accumulator_json TEXT,
+      rebuild_id TEXT,
+      FOREIGN KEY (singleton) REFERENCES tag_state_identity(singleton) ON DELETE RESTRICT
+    );
+  `);
+}
+/**
+ * TagState cache and resumable replay owner.  The only event source is the
+ * existing G43 Tag RPC; this object deliberately has neither a full-record
+ * fetch route nor a second source-query implementation.
+ */
+export class TagStateDurableObject {
+    ctx;
+    env;
+    g46CheckpointFault;
+    g46SourceNamespace;
+    /**
+     * Installed by the entrypoint when it composes the deployed domain.  There
+     * is deliberately no default/test-registry fallback here: a DO isolate
+     * which was not built from that composition must return the typed registry
+     * failure rather than fold with a different projector authority.
+     */
+    registry;
+    constructor(ctx, env, registry) {
+        this.ctx = ctx;
+        this.env = env;
+        this.registry = registry ?? configuredProjectorRegistry();
+        if (typeof ctx.storage.sql?.exec !== "function") {
+            throw new Error("TagState Durable Object requires SQLite storage");
+        }
+        initializeTagStateSchema(ctx.storage.sql);
+    }
+    /** Test-only fault seam for the two durable checkpoint boundaries. */
+    setG46CheckpointFaultForTest(fault) {
+        this.g46CheckpointFault = fault;
+    }
+    /** Test-only source seam; production always resolves `env.TAG`. */
+    setG46SourceNamespaceForTest(namespace) {
+        this.g46SourceNamespace = namespace;
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (request.method !== "POST" || url.pathname !== "/read") {
+            return error(404, "tag_state_route_not_found", "TagState route was not found");
+        }
+        let body;
+        try {
+            body = await request.json();
+        }
+        catch {
+            return error(400, "tag_state_validation_error", "TagState request must be JSON");
+        }
+        const identity = parseIdentity(body);
+        if (identity === undefined) {
+            return error(400, "tag_state_validation_error", "TagState identity requires serviceId, tag, and projectorId");
+        }
+        return await this.read(identity);
+    }
+    async read(identity) {
+        try {
+            this.ensureIdentity(identity);
+            const projector = this.resolveProjector(identity.projectorId);
+            let cache = this.readCache();
+            if (cache === undefined) {
+                cache = this.beginRebuild(projector, "cache-missing");
+            }
+            else if (cache.phase === "READY" && cache.projectorVersion !== projector.projectorVersion) {
+                cache = this.beginRebuild(projector, "projector-version-mismatch");
+            }
+            else if (cache.phase === "REBUILDING" && cache.targetProjectorVersion !== projector.projectorVersion) {
+                // The author changed its declared version while a previous rebuild was
+                // unfinished. Discard only the derived accumulator and restart from
+                // the source; the Tag DO remains the sole event authority.
+                cache = this.beginRebuild(projector, "target-projector-version-changed");
+            }
+            if (cache.phase === "READY") {
+                return await this.beginDeltaOrRespondReady(identity, projector, cache);
+            }
+            return await this.continueRebuild(identity, projector, cache);
+        }
+        catch (caught) {
+            if (caught instanceof TagStateIdentityConflict) {
+                return error(409, "tag_state_identity_conflict", "TagState Durable Object identity changed");
+            }
+            if (caught instanceof TagStateUnknownProjector) {
+                return error(404, "tag_state_unknown_projector", "TagState projector is not registered");
+            }
+            if (caught instanceof TagStateRegistryFailure) {
+                return error(503, "tag_state_projector_registry_failure", "TagState projector registry is unavailable");
+            }
+            if (caught instanceof TagStateSourceFailure) {
+                return error(caught.status, "tag_state_source_frontier_failure", "TagState source frontier could not be read");
+            }
+            if (caught instanceof TagStateCacheCorruption) {
+                // A corrupt cache is deliberately not an empty state. Start the
+                // source-backed rebuild now, then make this read distinguishable from
+                // both a normal empty tag and a later rebuild-in-progress response.
+                try {
+                    const projector = this.resolveProjector(identity.projectorId);
+                    this.beginRebuild(projector, "cache-corrupt");
+                }
+                catch (rebuildFailure) {
+                    if (rebuildFailure instanceof TagStateRegistryFailure) {
+                        return error(503, "tag_state_projector_registry_failure", "TagState projector registry is unavailable");
+                    }
+                }
+                return error(409, "tag_state_cache_corrupt", "TagState cache is corrupt and is rebuilding");
+            }
+            if (caught instanceof TagStateCheckpointFault) {
+                return error(503, "tag_state_rebuild_interrupted", "TagState replay checkpoint was interrupted");
+            }
+            return error(503, "tag_state_unavailable", "TagState cache is unavailable");
+        }
+    }
+    async beginDeltaOrRespondReady(identity, projector, cache) {
+        // Freeze the next delta before changing durable phase. A zero-event page
+        // completes immediately and preserves the legitimate empty initial state.
+        const page = await this.readSource(identity, cache.lastSuid, undefined);
+        if (page.events.length === 0 && page.completeThrough !== null) {
+            return json(this.success(projector, cache.stateJson, cache.lastSuid));
+        }
+        const rebuild = this.beginRebuild(projector, "normal-delta", {
+            cursor: cache.lastSuid,
+            accumulatorJson: cache.stateJson,
+            frozenThrough: page.through,
+        });
+        return this.foldAndCheckpoint(projector, rebuild, page);
+    }
+    async continueRebuild(identity, projector, cache) {
+        const page = await this.readSource(identity, cache.replayCursor, cache.frozenThrough);
+        return this.foldAndCheckpoint(projector, cache, page);
+    }
+    async foldAndCheckpoint(projector, cache, page) {
+        let state;
+        try {
+            state = projector.deserializeState(cache.accumulatorJson);
+            for (const event of page.events)
+                state = projector.apply(state, projectionEventFromTagEvent(event));
+        }
+        catch (caught) {
+            throw new TagStateCacheCorruption(caught);
+        }
+        let accumulatorJson;
+        try {
+            accumulatorJson = projector.serializeState(state);
+        }
+        catch (caught) {
+            throw new TagStateCacheCorruption(caught);
+        }
+        if (this.g46CheckpointFault === "before-checkpoint")
+            throw new TagStateCheckpointFault();
+        const complete = page.completeThrough !== null;
+        this.transaction(() => {
+            const sql = this.sql();
+            if (complete) {
+                sql.exec(`
+          UPDATE tag_state_cache
+          SET phase = 'READY', projector_version = ?, state_json = ?, last_suid = ?,
+              target_projector_version = NULL, frozen_through = NULL, replay_cursor = NULL,
+              accumulator_json = NULL, rebuild_id = NULL
+          WHERE singleton = 1
+        `, projector.projectorVersion, accumulatorJson, page.completeThrough);
+            }
+            else {
+                sql.exec(`
+          UPDATE tag_state_cache
+          SET frozen_through = ?, replay_cursor = ?, accumulator_json = ?
+          WHERE singleton = 1 AND phase = 'REBUILDING' AND rebuild_id = ?
+        `, page.through, page.lastSortableUniqueId, accumulatorJson, cache.rebuildId);
+            }
+        });
+        if (this.g46CheckpointFault === "after-checkpoint")
+            throw new TagStateCheckpointFault();
+        if (!complete) {
+            return error(503, "tag_state_rebuild_in_progress", "TagState replay is rebuilding to its frozen frontier");
+        }
+        return json(this.success(projector, accumulatorJson, page.completeThrough));
+    }
+    success(projector, stateJson, lastSortedUniqueId) {
+        try {
+            const state = projector.deserializeState(stateJson);
+            return {
+                kind: "ready",
+                payload: projector.payload(state),
+                version: projector.version(state),
+                lastSortedUniqueId,
+                projectorVersion: projector.projectorVersion,
+            };
+        }
+        catch (caught) {
+            throw new TagStateCacheCorruption(caught);
+        }
+    }
+    async readSource(identity, cursor, through) {
+        if (cursor !== "")
+            assertSortableUniqueId(cursor);
+        if (through !== undefined && through !== null && through !== "")
+            assertSortableUniqueId(through);
+        try {
+            const namespace = this.g46SourceNamespace ?? this.env.TAG;
+            const stub = namespace.get(scopeIdFor(namespace, {
+                serviceId: identity.serviceId,
+                doClass: "tag",
+                identity: identity.tag,
+            }));
+            const sourceUrl = new URL("https://tag-source.internal/__internal/g46/tag-state-incremental");
+            sourceUrl.searchParams.set("__tag", identity.tag);
+            sourceUrl.searchParams.set("__serviceId", identity.serviceId);
+            const response = await stub.fetch(new Request(sourceUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    "x-sdt-g46-source-read": "1",
+                },
+                body: JSON.stringify({
+                    tag: identity.tag,
+                    cursor,
+                    limit: TAG_STATE_SOURCE_PAGE_LIMIT,
+                    ...(through === undefined || through === null ? {} : { through }),
+                }),
+            }));
+            if (response.status !== 200) {
+                const detail = await response.text();
+                const identityConflict = response.status === 409;
+                throw new TagStateSourceFailure(identityConflict ? 409 : 503, new Error(detail));
+            }
+            const page = await response.json();
+            this.assertSourcePage(cursor, through, page);
+            return page;
+        }
+        catch (caught) {
+            if (caught instanceof TagStateSourceFailure)
+                throw caught;
+            const identityConflict = caught instanceof Error && caught.name === "TagIdentityConflict";
+            throw new TagStateSourceFailure(identityConflict ? 409 : 503, caught);
+        }
+    }
+    assertSourcePage(cursor, expectedThrough, page) {
+        if (!isObject(page) || !Array.isArray(page.events) || typeof page.lastSortableUniqueId !== "string" ||
+            typeof page.through !== "string" || (page.completeThrough !== null && typeof page.completeThrough !== "string")) {
+            throw new TagStateSourceFailure(503, new Error("TagState source response was malformed"));
+        }
+        if (expectedThrough !== undefined && expectedThrough !== null && page.through !== expectedThrough) {
+            throw new TagStateSourceFailure(503, new Error("TagState source changed its frozen frontier"));
+        }
+        if (page.through !== "")
+            assertSortableUniqueId(page.through);
+        let prior = cursor;
+        for (const event of page.events) {
+            assertSortableUniqueId(event.suid);
+            if (prior !== "" && compareSortableUniqueId(event.suid, prior) <= 0) {
+                throw new TagStateSourceFailure(503, new Error("TagState source cursor did not advance"));
+            }
+            if (page.through !== "" && compareSortableUniqueId(event.suid, page.through) > 0) {
+                throw new TagStateSourceFailure(503, new Error("TagState source read beyond its frozen frontier"));
+            }
+            prior = event.suid;
+        }
+        const expectedLast = page.events.length === 0 ? cursor : prior;
+        if (page.lastSortableUniqueId !== expectedLast) {
+            throw new TagStateSourceFailure(503, new Error("TagState source cursor/result mismatch"));
+        }
+        if (page.completeThrough !== null && page.completeThrough !== page.through) {
+            throw new TagStateSourceFailure(503, new Error("TagState source completion frontier mismatch"));
+        }
+    }
+    resolveProjector(projectorId) {
+        try {
+            const registry = this.registry;
+            if (registry === undefined) {
+                throw new TagStateRegistryFailure(new Error("TagState projector registry was not installed by the runtime composition"));
+            }
+            const projector = registry.resolve(projectorId);
+            if (projector === undefined)
+                throw new TagStateUnknownProjector();
+            return projector;
+        }
+        catch (caught) {
+            if (caught instanceof TagStateUnknownProjector || caught instanceof TagStateRegistryFailure)
+                throw caught;
+            throw new TagStateRegistryFailure(caught);
+        }
+    }
+    ensureIdentity(identity) {
+        const row = this.sql().exec(`
+      SELECT service_id, tag, projector_id
+      FROM tag_state_identity
+      WHERE singleton = 1
+    `).toArray()[0];
+        if (row === undefined) {
+            this.transaction(() => {
+                this.sql().exec(`
+          INSERT INTO tag_state_identity (singleton, service_id, tag, projector_id)
+          VALUES (1, ?, ?, ?)
+        `, identity.serviceId, identity.tag, identity.projectorId);
+            });
+            return;
+        }
+        if (sqlString(row.service_id, "tag_state_identity.service_id") !== identity.serviceId ||
+            sqlString(row.tag, "tag_state_identity.tag") !== identity.tag ||
+            sqlString(row.projector_id, "tag_state_identity.projector_id") !== identity.projectorId)
+            throw new TagStateIdentityConflict();
+    }
+    readCache() {
+        const row = this.sql().exec(`
+      SELECT phase, projector_version, state_json, last_suid,
+             target_projector_version, frozen_through, replay_cursor,
+             accumulator_json, rebuild_id
+      FROM tag_state_cache
+      WHERE singleton = 1
+    `).toArray()[0];
+        if (row === undefined)
+            return undefined;
+        const phase = sqlString(row.phase, "tag_state_cache.phase");
+        if (phase === "READY") {
+            return {
+                phase,
+                projectorVersion: sqlString(row.projector_version, "tag_state_cache.projector_version"),
+                stateJson: sqlString(row.state_json, "tag_state_cache.state_json"),
+                lastSuid: sqlString(row.last_suid, "tag_state_cache.last_suid"),
+            };
+        }
+        if (phase === "REBUILDING") {
+            return {
+                phase,
+                targetProjectorVersion: sqlString(row.target_projector_version, "tag_state_cache.target_projector_version"),
+                frozenThrough: sqlNullableString(row.frozen_through, "tag_state_cache.frozen_through"),
+                replayCursor: sqlString(row.replay_cursor, "tag_state_cache.replay_cursor"),
+                accumulatorJson: sqlString(row.accumulator_json, "tag_state_cache.accumulator_json"),
+                rebuildId: sqlString(row.rebuild_id, "tag_state_cache.rebuild_id"),
+            };
+        }
+        throw new TagStateCacheCorruption(new Error("TagState cache phase was invalid"));
+    }
+    beginRebuild(projector, _reason, existing = undefined) {
+        let accumulatorJson;
+        try {
+            accumulatorJson = existing?.accumulatorJson ?? projector.serializeState(projector.initialState());
+            // Validate the serialized state before it becomes a durable rebuild
+            // accumulator. A bad registry reducer is a registry failure, not an
+            // empty successful projection.
+            projector.deserializeState(accumulatorJson);
+        }
+        catch (caught) {
+            throw new TagStateRegistryFailure(caught);
+        }
+        const rebuild = {
+            phase: "REBUILDING",
+            targetProjectorVersion: projector.projectorVersion,
+            frozenThrough: existing?.frozenThrough ?? null,
+            replayCursor: existing?.cursor ?? "",
+            accumulatorJson,
+            rebuildId: crypto.randomUUID(),
+        };
+        this.transaction(() => {
+            this.sql().exec(`
+        INSERT INTO tag_state_cache (
+          singleton, phase, projector_version, state_json, last_suid,
+          target_projector_version, frozen_through, replay_cursor,
+          accumulator_json, rebuild_id
+        ) VALUES (1, 'REBUILDING', NULL, NULL, '', ?, ?, ?, ?, ?)
+        ON CONFLICT(singleton) DO UPDATE SET
+          phase = excluded.phase,
+          projector_version = NULL,
+          state_json = NULL,
+          last_suid = '',
+          target_projector_version = excluded.target_projector_version,
+          frozen_through = excluded.frozen_through,
+          replay_cursor = excluded.replay_cursor,
+          accumulator_json = excluded.accumulator_json,
+          rebuild_id = excluded.rebuild_id
+      `, rebuild.targetProjectorVersion, rebuild.frozenThrough, rebuild.replayCursor, rebuild.accumulatorJson, rebuild.rebuildId);
+        });
+        return rebuild;
+    }
+    sql() {
+        const sql = this.ctx.storage.sql;
+        if (typeof sql?.exec !== "function")
+            throw new Error("TagState Durable Object requires SQLite storage");
+        return sql;
+    }
+    transaction(callback) {
+        const storage = this.ctx.storage;
+        if (typeof storage.transactionSync !== "function") {
+            throw new Error("TagState Durable Object requires SQLite transactionSync");
+        }
+        storage.transactionSync(callback);
+    }
+}

package/dist/trace/AttributionRatio.d.ts

@@ -0,0 +1,12 @@
+import type { CommitTraceSnapshot } from "./CommitTrace";
+export interface UnattributedRatio {
+    readonly rootDurationMs: number;
+    readonly coveredDurationMs: number;
+    readonly unattributedRatio: number;
+}
+/**
+ * The attribution numerator is the union of caller-domain coverage only.
+ * Callee, nested, fan-out-member, and provider-derived intervals are never
+ * eligible, even if a provider happens to attach a duration to them.
+ */
+export declare function calculateUnattributedRatio(snapshot: CommitTraceSnapshot): UnattributedRatio;

package/dist/trace/AttributionRatio.js

@@ -0,0 +1,68 @@
+import commitTraceManifestJson from "../../../../contracts/commit-trace-manifest.json";
+function failure(code, message) {
+    const error = new Error(`${code}:${message}`);
+    error.name = "CommitTraceAttributionError";
+    throw error;
+}
+function clip(interval, root) {
+    const start = Math.max(interval[0], root[0]);
+    const end = Math.min(interval[1], root[1]);
+    return end < start ? undefined : [start, end];
+}
+function unionDuration(intervals) {
+    const sorted = [...intervals].sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+    let duration = 0;
+    let current;
+    for (const interval of sorted) {
+        if (current === undefined) {
+            current = [interval[0], interval[1]];
+            continue;
+        }
+        if (interval[0] <= current[1]) {
+            current[1] = Math.max(current[1], interval[1]);
+            continue;
+        }
+        duration += current[1] - current[0];
+        current = [interval[0], interval[1]];
+    }
+    return duration + (current === undefined ? 0 : current[1] - current[0]);
+}
+/**
+ * The attribution numerator is the union of caller-domain coverage only.
+ * Callee, nested, fan-out-member, and provider-derived intervals are never
+ * eligible, even if a provider happens to attach a duration to them.
+ */
+export function calculateUnattributedRatio(snapshot) {
+    if (snapshot.schema !== "sdt.commit/v1")
+        failure("ratio-schema", "unattributed ratio is defined for sdt.commit/v1 only");
+    const root = snapshot.spans.find((span) => span.rowId === "S00");
+    if (root === undefined)
+        failure("ratio-root-missing", "sdt.commit/v1 needs S00");
+    const manifest = commitTraceManifestJson;
+    const coverage = new Set(manifest.schemas["sdt.commit/v1"].callerCoverageIntervals);
+    const rows = new Map(manifest.schemas["sdt.commit/v1"].rows.map((row) => [row.rowId, row]));
+    const rootInterval = [root.startMs, root.endMs];
+    const intervals = snapshot.spans
+        .filter((span) => coverage.has(span.rowId))
+        .map((span) => {
+        const row = rows.get(span.rowId);
+        if (row === undefined)
+            failure("coverage-row", `coverage row ${span.rowId} is not manifest-declared`);
+        if (span.clockDomain !== "caller" ||
+            row.emitter === "callee-do" ||
+            row.kind === "nested" ||
+            row.kind === "fanout-member" ||
+            row.kind === "sequential-member") {
+            failure("coverage-noncaller", `${span.rowId} is forbidden from caller coverage`);
+        }
+        return clip([span.startMs, span.endMs], rootInterval);
+    })
+        .filter((interval) => interval !== undefined);
+    const rootDurationMs = Math.max(0, root.endMs - root.startMs);
+    const coveredDurationMs = Math.min(rootDurationMs, unionDuration(intervals));
+    return {
+        rootDurationMs,
+        coveredDurationMs,
+        unattributedRatio: rootDurationMs === 0 ? 0 : Math.max(0, rootDurationMs - coveredDurationMs) / rootDurationMs,
+    };
+}

package/dist/trace/CloudflareTracing.d.ts

@@ -0,0 +1,7 @@
+import type { NativeTracing } from "./CommitTrace";
+/**
+ * The Worker runtime, not application code, establishes parentage. Both
+ * entrypoints expose the identical API; using the module form lets Durable
+ * Object handlers participate without adding a header or body field.
+ */
+export declare function cloudflareTracing(context?: Pick<ExecutionContext, "tracing">): NativeTracing;

package/dist/trace/CloudflareTracing.js

@@ -0,0 +1,9 @@
+import { tracing } from "cloudflare:workers";
+/**
+ * The Worker runtime, not application code, establishes parentage. Both
+ * entrypoints expose the identical API; using the module form lets Durable
+ * Object handlers participate without adding a header or body field.
+ */
+export function cloudflareTracing(context) {
+    return (context?.tracing ?? tracing);
+}