iterate 0.3.0 → 0.4.0

package/dist/processors-testing.mjs

@@ -1,435 +0,0 @@
-import { o as StreamProcessorRunner } from "./stream-processor-keepalive-DAQTP6m3.mjs";
-import { n as durableObjectRecovery, t as durableObjectProgressStore } from "./durable-object-processor-durability-CNsTjAJS.mjs";
-import { i as sameIdempotentEvent, t as idempotencyConflictMessage } from "./idempotency-DleloJNt.mjs";
-//#region src/processors/testing.ts
-function emptyThroughputReport() {
-	return {
-		perSecond5s: 0,
-		bytesPerSecond5s: 0,
-		lastMinute: {
-			count: 0,
-			bytes: 0,
-			perSecond: 0
-		},
-		series: {
-			counts: new Array(60).fill(0),
-			bytes: new Array(60).fill(0)
-		}
-	};
-}
-/** The empty `runtimeState()` answer the test MemoryStream serves. */
-function emptyStreamRuntimeState() {
-	return {
-		coreProcessorState: null,
-		runtime: {
-			connections: {},
-			sending: {},
-			metrics: {
-				measuredSince: (/* @__PURE__ */ new Date(0)).toISOString(),
-				reportedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-				ingress: emptyThroughputReport(),
-				egress: emptyThroughputReport()
-			},
-			storageSizeBytes: 0
-		}
-	};
-}
-var MemoryStream = class {
-	events = [];
-	streamId = crypto.randomUUID();
-	/** Injectable clock for createdAt stamps; harnesses point it at virtual time. */
-	now = Date.now;
-	/** Simulate a transient Stream DO outage: appends of this type throw. */
-	failAppendsOfType;
-	/**
-	* OPT-IN ASYNCHRONOUS COMMIT. Undefined — the default — is today's behaviour
-	* and every existing suite's behaviour.
-	*
-	* `append` below validates and publishes in its own SYNCHRONOUS body: it is
-	* declared `async`, but nothing inside it awaits, so the events are in
-	* `this.events` and their offsets are taken before the returned promise is
-	* even handed back. Two call sites therefore commit in the order they
-	* CALLED, whoever awaited and whoever did not. That determinism is what
-	* makes scenario steps reproducible and it is why ~250 suites rest on it.
-	*
-	* It is also a lie about production. A real append is an RPC to the Stream
-	* Durable Object; two of them can be in flight at once, and the one issued
-	* first is not guaranteed to commit first. Every ordering bug of that shape
-	* — an un-awaited append racing an awaited one, and the un-awaited one
-	* losing — is structurally invisible here.
-	*
-	* Set this and an append waits for the returned promise before it validates
-	* anything or takes an offset, so offsets are assigned at COMMIT the way the
-	* Durable Object assigns them. Return `undefined` to let a batch commit at
-	* once, which is what keeps the cost of the mode to the batches a test
-	* actually cares about.
-	*
-	* A test is expected to DECIDE which of two in-flight appends wins rather
-	* than to wait and see: a race whose loser cannot be pinned is a flake, not
-	* a test. Whatever the hook waits on must be bounded, because the fix for
-	* such a bug is usually to make the overtake impossible — and then a hook
-	* that waits for it forever hangs the suite that proves it.
-	*/
-	holdAppend;
-	/** Set by MemoryStreamNetwork.get(); a detached stream answers `at()` with itself. */
-	network;
-	path;
-	constructor(path = "/agents/test") {
-		this.path = path;
-	}
-	async __describe() {
-		return {
-			instructions: "in-memory test stream",
-			types: "",
-			children: {}
-		};
-	}
-	async kill() {}
-	async append(...inputs) {
-		const held = this.holdAppend?.(inputs);
-		if (held !== void 0) await held;
-		const staged = [];
-		const results = [];
-		let nextOffset = (this.events.at(-1)?.offset ?? 0) + 1;
-		for (const input of inputs) {
-			if (input.type === this.failAppendsOfType) throw new Error(`injected append failure for ${input.type}`);
-			const detachedInput = {
-				...input,
-				...input.payload === void 0 ? {} : { payload: JSON.parse(JSON.stringify(input.payload)) },
-				...input.metadata === void 0 ? {} : { metadata: JSON.parse(JSON.stringify(input.metadata)) }
-			};
-			const existing = detachedInput.idempotencyKey === void 0 ? void 0 : [...this.events, ...staged].find((event) => event.idempotencyKey === detachedInput.idempotencyKey);
-			if (existing !== void 0 && detachedInput.idempotencyKey !== void 0) {
-				if (!sameIdempotentEvent(existing, detachedInput)) throw new Error(idempotencyConflictMessage(detachedInput.idempotencyKey, existing.offset));
-				results.push(existing);
-				continue;
-			}
-			const event = {
-				...detachedInput,
-				createdAt: new Date(this.now()).toISOString(),
-				offset: nextOffset++,
-				path: this.path
-			};
-			staged.push(event);
-			results.push(event);
-		}
-		this.events.push(...staged);
-		return results;
-	}
-	appendIfStreamId(args) {
-		if (args.streamId !== this.streamId) throw new Error(`stream ID changed (${args.streamId} -> ${this.streamId}); append rejected`);
-		return this.append(...args.events);
-	}
-	at(path) {
-		return path === void 0 || this.network === void 0 ? this : this.network.get(path);
-	}
-	async getEvent(input) {
-		if ("offset" in input) return this.events.find((event) => event.offset === input.offset);
-		return this.events.find((event) => event.idempotencyKey === input.idempotencyKey);
-	}
-	async getEvents(input = {}) {
-		const { afterOffset = 0, limit = 500 } = input;
-		const beforeOffset = input.beforeOffset ?? Number.MAX_SAFE_INTEGER;
-		const matching = this.events.filter((event) => event.offset > afterOffset).filter((event) => event.offset < beforeOffset).filter((event) => input.eventTypes === void 0 || input.eventTypes.includes("*") || input.eventTypes.includes(event.type)).slice(0, limit);
-		const byteLimit = input.byteLimit;
-		if (byteLimit === void 0) return matching;
-		let bytes = 0;
-		return matching.filter((event, index) => {
-			bytes += new TextEncoder().encode(JSON.stringify(event)).byteLength;
-			return bytes <= byteLimit || index === 0;
-		});
-	}
-	async getEventPage(input = {}) {
-		return {
-			streamId: this.streamId,
-			streamMaxOffset: this.events.at(-1)?.offset ?? 0,
-			events: await this.getEvents(input)
-		};
-	}
-	readEvents(input = {}) {
-		let afterOffset = input.afterOffset ?? 0;
-		return {
-			next: async () => {
-				const page = await this.getEvents({
-					...input,
-					afterOffset
-				});
-				afterOffset = page.at(-1)?.offset ?? afterOffset;
-				return page;
-			},
-			[Symbol.dispose]() {}
-		};
-	}
-	async waitForEvent(input) {
-		const deadline = Date.now() + input.timeoutMs;
-		while (Date.now() < deadline) {
-			for (const event of this.events) {
-				if (input.afterOffset !== void 0 && event.offset <= input.afterOffset) continue;
-				if (input.eventTypes !== void 0 && !input.eventTypes.includes(event.type)) continue;
-				if (input.predicate !== void 0 && !await input.predicate(event)) continue;
-				return event;
-			}
-			await new Promise((resolve) => setTimeout(resolve, 10));
-		}
-		throw new Error("Timed out waiting for event");
-	}
-	async getProcessorRuntimeState() {
-		return null;
-	}
-	async runtimeState() {
-		return emptyStreamRuntimeState();
-	}
-};
-/**
-* In-memory network of streams keyed by path, so router tests can observe
-* the cross-stream forwards (`stream.at(path).append(...)`) next to
-* same-stream appends. `now` feeds every member stream's createdAt stamp, so
-* freshness checks (such as webhook acknowledgement horizons) can be tested on both sides
-* of the horizon. `eventsAt` never creates a stream — `network.streams.size`
-* assertions ("nothing was forwarded anywhere") stay honest.
-*/
-var MemoryStreamNetwork = class {
-	streams = /* @__PURE__ */ new Map();
-	now;
-	constructor(now = Date.now) {
-		this.now = now;
-	}
-	get(path) {
-		let stream = this.streams.get(path);
-		if (stream === void 0) {
-			stream = new MemoryStream(path);
-			stream.network = this;
-			stream.now = this.now;
-			this.streams.set(path, stream);
-		}
-		return stream;
-	}
-	eventsAt(path) {
-		return this.streams.get(path)?.events ?? [];
-	}
-};
-const durabilitySubstrates = /* @__PURE__ */ new WeakMap();
-const progressSubstrates = /* @__PURE__ */ new WeakMap();
-function makeDurabilitySubstrate() {
-	const kv = /* @__PURE__ */ new Map();
-	const alarm = { at: null };
-	return {
-		storage: {
-			kv: {
-				get: (key) => kv.has(key) ? structuredClone(kv.get(key)) : void 0,
-				put: (key, value) => void kv.set(key, structuredClone(value)),
-				delete: (key) => kv.delete(key)
-			},
-			getAlarm: async () => alarm.at,
-			setAlarm: async (at) => {
-				alarm.at = at;
-			},
-			deleteAlarm: async () => {
-				alarm.at = null;
-			}
-		},
-		alarm
-	};
-}
-/** In-memory {@link ProcessorProgressStore} with the DO store's fencing check,
-* so progress survives `crash()` into the successor incarnation. Exported so
-* suites can hand a harness a FRESH store over an existing stream — a full
-* replay from offset zero, which is both the re-reduce-from-scratch recipe and the harshest
-* at-least-once redelivery test (every per-event append re-runs).
-*
-* The contract is required because progress and recovery share the same
-* per-processor Durable Object keys. A generic placeholder slug would let the
-* runner commit progress under one key while recovery looks under another.
-*/
-function makeMemoryProgressStore(contract) {
-	const durability = makeDurabilitySubstrate();
-	const progress = durableObjectProgressStore({
-		storage: durability.storage,
-		name: contract.slug
-	});
-	progressSubstrates.set(progress, durability);
-	return progress;
-}
-/**
-* Build a {@link ProcessorHarness}: the real runner, ProcessorKeepalive, and
-* Durable Object durability adapters over an in-memory stream/KV/alarm
-* substrate. `crash()` is eviction: delivery stays detached until a new
-* append wakes it or a due keepalive alarm appends the revival fact. Pass
-* another harness's `substrate` to run a second incarnation over the same
-* durable state (the zombie-race setup).
-*
-* Appends commit synchronously unless a suite opts out through
-* `harness.stream.holdAppend` — the one seam for reproducing a processor that
-* appends the same lane from two places and orders only one of them.
-*/
-function makeProcessorHarness(args) {
-	const path = args.substrate?.stream.path ?? args.path ?? "/harness/processor";
-	const clock = args.substrate?.clock ?? { now: 1e6 };
-	const stream = args.substrate?.stream ?? new MemoryStream(path);
-	stream.now = () => clock.now;
-	const durability = (args.substrate === void 0 ? void 0 : durabilitySubstrates.get(args.substrate) ?? progressSubstrates.get(args.substrate.progress)) ?? makeDurabilitySubstrate();
-	let progress = args.substrate?.progress;
-	let pendingSleeps = [];
-	const releaseDueSleeps = () => {
-		const due = pendingSleeps.filter((sleep) => sleep.dueAt <= clock.now);
-		pendingSleeps = pendingSleeps.filter((sleep) => sleep.dueAt > clock.now);
-		for (const sleep of due) sleep.resolve();
-		return due.length;
-	};
-	let processor;
-	let runner;
-	let recovery;
-	let incarnation = 0;
-	let deliveryEnabled = true;
-	let deliveryAttempt;
-	let deliveryError;
-	const keepAlive = (work) => {
-		work.catch(() => void 0);
-	};
-	const incarnate = () => {
-		processor = args.createProcessor({
-			stream,
-			path,
-			projectId: "proj_harness",
-			now: () => clock.now,
-			sleep: (ms) => new Promise((resolve) => pendingSleeps.push({
-				dueAt: clock.now + ms,
-				resolve
-			})),
-			reads: {
-				snapshot: () => runner.snapshot(),
-				waitUntilEvent: (input) => "offset" in input ? runner.waitUntilEvent(input) : runner.waitUntilEvent(input)
-			}
-		});
-		progress ??= durableObjectProgressStore({
-			storage: durability.storage,
-			name: processor.contract.slug
-		});
-		recovery = durableObjectRecovery({
-			storage: durability.storage,
-			name: processor.contract.slug,
-			stream,
-			version: "test-harness",
-			armAlarm: (atMs) => {
-				if (atMs === null) durability.storage.deleteAlarm();
-				else durability.storage.setAlarm(atMs);
-			},
-			waitUntil: keepAlive,
-			now: () => clock.now
-		});
-		runner = new StreamProcessorRunner({
-			processor,
-			stream,
-			durability: {
-				progress,
-				recovery
-			},
-			keepAlive: (work) => keepAlive(work()),
-			now: () => clock.now,
-			readPageSize: 5
-		});
-	};
-	incarnate();
-	const substrate = {
-		clock,
-		stream,
-		progress
-	};
-	if (args.substrate !== void 0) durabilitySubstrates.set(args.substrate, durability);
-	durabilitySubstrates.set(substrate, durability);
-	progressSubstrates.set(substrate.progress, durability);
-	const startDelivery = () => {
-		if (deliveryAttempt !== void 0) return;
-		const deliveryIncarnation = incarnation;
-		const attempt = runner.catchUp();
-		deliveryAttempt = attempt;
-		attempt.then(() => {
-			if (deliveryIncarnation === incarnation) deliveryAttempt = void 0;
-		}, (error) => {
-			if (deliveryIncarnation !== incarnation) return;
-			deliveryAttempt = void 0;
-			deliveryError = error;
-		});
-	};
-	const settle = async () => {
-		let quietRounds = 0;
-		let lastAppendedTypes = [];
-		for (let round = 0; round < 50; round++) {
-			const headBefore = stream.events.at(-1)?.offset ?? 0;
-			const releasedSleeps = releaseDueSleeps();
-			if (deliveryEnabled) startDelivery();
-			await new Promise((resolve) => setTimeout(resolve, 0));
-			if (deliveryError !== void 0) {
-				const error = deliveryError;
-				deliveryError = void 0;
-				throw error;
-			}
-			const headAfter = stream.events.at(-1)?.offset ?? 0;
-			lastAppendedTypes = stream.events.filter((event) => event.offset > headBefore).map((event) => event.type);
-			quietRounds = headAfter === headBefore && releasedSleeps === 0 ? quietRounds + 1 : 0;
-			if (quietRounds === 3 && (!deliveryEnabled || deliveryAttempt === void 0 || durability.alarm.at !== null)) return;
-		}
-		const headOffset = stream.events.at(-1)?.offset ?? 0;
-		throw new Error(`harness settle() did not reach a fixpoint in 50 rounds; last round appended event types: ${lastAppendedTypes.join(", ") || "none"}; head offset: ${headOffset}`);
-	};
-	const append = async (...events) => {
-		await stream.append(...events);
-		deliveryEnabled = true;
-		await settle();
-	};
-	const advanceTime = async (ms) => {
-		const target = clock.now + ms;
-		while (durability.alarm.at !== null && durability.alarm.at <= target) {
-			clock.now = Math.max(clock.now, durability.alarm.at);
-			durability.alarm.at = null;
-			await recovery.handleAlarm();
-			deliveryEnabled = true;
-			await settle();
-		}
-		clock.now = target;
-		await settle();
-	};
-	const crash = () => {
-		runner.dispose();
-		incarnation += 1;
-		deliveryEnabled = false;
-		deliveryAttempt = void 0;
-		deliveryError = void 0;
-		pendingSleeps = [];
-		incarnate();
-	};
-	return {
-		clock,
-		stream,
-		substrate,
-		runner: () => runner,
-		processor: () => processor,
-		append,
-		advanceTime,
-		crash,
-		settle,
-		state: () => runner.currentState,
-		events: ((type) => type === void 0 ? [...stream.events] : stream.events.filter((row) => row.type === type)),
-		async play(...steps) {
-			for (const [index, step] of steps.entries()) {
-				const kind = typeof step === "function" ? "function" : step[0];
-				try {
-					if (typeof step === "function") {
-						await step();
-						await settle();
-					} else if (step[0] === "append") {
-						const [, ...events] = step;
-						await append(...events);
-					} else if (step[0] === "advanceTime") await advanceTime(step[1]);
-					else crash();
-				} catch (error) {
-					throw new Error(`harness play() step ${index} (${kind}) failed`, { cause: error });
-				}
-			}
-		}
-	};
-}
-//#endregion
-export { MemoryStream, MemoryStreamNetwork, makeMemoryProgressStore, makeProcessorHarness };
-
-//# sourceMappingURL=processors-testing.mjs.map

package/dist/processors-testing.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"processors-testing.mjs","names":[],"sources":["../src/processors/testing.ts"],"sourcesContent":["// In-memory test doubles for the stream substrate — the ONE MemoryStream\n// (plus MemoryStreamNetwork for router suites observing cross-stream\n// forwards). The generic step harness drives the real runner over that\n// in-memory stream.\n// Step tuples form scenario spines; `h.append`/`h.advanceTime` settle single\n// actions, while `h.stream.append` commits without driving delivery.\n// Every harness uses the production DO durability adapters over in-memory KV\n// plus an alarm cell, so eviction and revival have one meaning in every suite.\n\nimport {\n  durableObjectProgressStore,\n  durableObjectRecovery,\n} from \"./durable-object-processor-durability.ts\";\nimport { idempotencyConflictMessage, sameIdempotentEvent } from \"./idempotency.ts\";\nimport type { StreamEvent, StreamEventInput } from \"./schemas.ts\";\nimport type { StreamEventReadInput } from \"./rpc-types.ts\";\nimport type { ConsumedInput, ProcessorState, ResolvedEvent } from \"./processor-contracts.ts\";\nimport type { RegisteredProcessorReads } from \"./stream-processor-registry.ts\";\nimport type { ProcessorStream } from \"./stream-handle.ts\";\nimport type { StreamProcessor, StreamProcessorContract } from \"./stream-processor.ts\";\nimport type { ProcessorProgressStore } from \"./stream-processor-runner.ts\";\nimport { StreamProcessorRunner } from \"./stream-processor-runner.ts\";\n\nfunction emptyThroughputReport() {\n  return {\n    perSecond5s: 0,\n    bytesPerSecond5s: 0,\n    lastMinute: { count: 0, bytes: 0, perSecond: 0 },\n    series: { counts: new Array(60).fill(0), bytes: new Array(60).fill(0) },\n  };\n}\n\n/** The empty `runtimeState()` answer the test MemoryStream serves. */\nfunction emptyStreamRuntimeState() {\n  return {\n    coreProcessorState: null,\n    runtime: {\n      connections: {},\n      sending: {},\n      metrics: {\n        measuredSince: new Date(0).toISOString(),\n        reportedAt: new Date(0).toISOString(),\n        ingress: emptyThroughputReport(),\n        egress: emptyThroughputReport(),\n      },\n      storageSizeBytes: 0,\n    },\n  };\n}\n\n// Deliberately typed against the narrow ProcessorStream handle (what the\n// machinery depends on), not the full generated `Stream` — the extra methods\n// below (getEvent/getEvents/waitForEvent, runtime-state stubs) exist for test\n// assertions and for suites that treat the double as a fuller stream.\nexport class MemoryStream implements ProcessorStream {\n  events: StreamEvent[] = [];\n  streamId = crypto.randomUUID();\n  /** Injectable clock for createdAt stamps; harnesses point it at virtual time. */\n  now: () => number = Date.now;\n  /** Simulate a transient Stream DO outage: appends of this type throw. */\n  failAppendsOfType: string | undefined;\n  /**\n   * OPT-IN ASYNCHRONOUS COMMIT. Undefined — the default — is today's behaviour\n   * and every existing suite's behaviour.\n   *\n   * `append` below validates and publishes in its own SYNCHRONOUS body: it is\n   * declared `async`, but nothing inside it awaits, so the events are in\n   * `this.events` and their offsets are taken before the returned promise is\n   * even handed back. Two call sites therefore commit in the order they\n   * CALLED, whoever awaited and whoever did not. That determinism is what\n   * makes scenario steps reproducible and it is why ~250 suites rest on it.\n   *\n   * It is also a lie about production. A real append is an RPC to the Stream\n   * Durable Object; two of them can be in flight at once, and the one issued\n   * first is not guaranteed to commit first. Every ordering bug of that shape\n   * — an un-awaited append racing an awaited one, and the un-awaited one\n   * losing — is structurally invisible here.\n   *\n   * Set this and an append waits for the returned promise before it validates\n   * anything or takes an offset, so offsets are assigned at COMMIT the way the\n   * Durable Object assigns them. Return `undefined` to let a batch commit at\n   * once, which is what keeps the cost of the mode to the batches a test\n   * actually cares about.\n   *\n   * A test is expected to DECIDE which of two in-flight appends wins rather\n   * than to wait and see: a race whose loser cannot be pinned is a flake, not\n   * a test. Whatever the hook waits on must be bounded, because the fix for\n   * such a bug is usually to make the overtake impossible — and then a hook\n   * that waits for it forever hangs the suite that proves it.\n   */\n  holdAppend: ((events: readonly StreamEventInput[]) => Promise<void> | undefined) | undefined;\n  /** Set by MemoryStreamNetwork.get(); a detached stream answers `at()` with itself. */\n  network: MemoryStreamNetwork | undefined;\n\n  readonly path: string;\n\n  constructor(path = \"/agents/test\") {\n    this.path = path;\n  }\n\n  async __describe() {\n    return { instructions: \"in-memory test stream\", types: \"\", children: {} };\n  }\n\n  async kill(): Promise<void> {}\n\n  async append(...inputs: StreamEventInput[]): Promise<StreamEvent[]> {\n    // Before ANYTHING else, including taking offsets: see `holdAppend`. The\n    // `undefined` check keeps the default path free of an await, so with no\n    // hook installed this method still commits inside its synchronous body.\n    const held = this.holdAppend?.(inputs);\n    if (held !== undefined) await held;\n    // TWO-PHASE like the Stream DO: validate the whole batch against existing\n    // AND same-batch state first, then publish — a failing input must not\n    // leave earlier inputs committed (production batches are atomic).\n    const staged: StreamEvent[] = [];\n    const results: StreamEvent[] = [];\n    // Next offset comes from the last event, not the array length — seeded\n    // histories (e.g. stream-repros fixtures with bulk event types dropped)\n    // have offset gaps.\n    let nextOffset = (this.events.at(-1)?.offset ?? 0) + 1;\n    for (const input of inputs) {\n      if (input.type === this.failAppendsOfType) {\n        throw new Error(`injected append failure for ${input.type}`);\n      }\n      // The casts restate what the round-trip preserves: serializing a\n      // `Record<string, unknown>` yields a JSON object, so parsing it back\n      // yields one — `JSON.parse` just types as `any` and cannot say so.\n      const detachedInput: StreamEventInput = {\n        ...input,\n        ...(input.payload === undefined\n          ? {}\n          : { payload: JSON.parse(JSON.stringify(input.payload)) as Record<string, unknown> }),\n        ...(input.metadata === undefined\n          ? {}\n          : { metadata: JSON.parse(JSON.stringify(input.metadata)) as Record<string, unknown> }),\n      };\n      const existing =\n        detachedInput.idempotencyKey === undefined\n          ? undefined\n          : [...this.events, ...staged].find(\n              (event) => event.idempotencyKey === detachedInput.idempotencyKey,\n            );\n      if (existing !== undefined && detachedInput.idempotencyKey !== undefined) {\n        // The Stream DO's predicate, SHARED: a same-key append with a\n        // DIFFERENT body is REJECTED, not deduplicated. Key-only dedup here\n        // once masked exactly that production rejection from a test.\n        if (!sameIdempotentEvent(existing, detachedInput)) {\n          throw new Error(\n            idempotencyConflictMessage(detachedInput.idempotencyKey, existing.offset),\n          );\n        }\n        results.push(existing);\n        continue;\n      }\n      const event: StreamEvent = {\n        ...detachedInput,\n        // Wall-clock like production, not offset-derived: expiry policy reads\n        // createdAt, and epoch-1970 stamps would expire everything on arrival.\n        createdAt: new Date(this.now()).toISOString(),\n        offset: nextOffset++,\n        path: this.path,\n      };\n      staged.push(event);\n      results.push(event);\n    }\n    this.events.push(...staged);\n    return results;\n  }\n\n  appendIfStreamId(args: { streamId: string; events: StreamEventInput[] }): Promise<StreamEvent[]> {\n    if (args.streamId !== this.streamId) {\n      throw new Error(`stream ID changed (${args.streamId} -> ${this.streamId}); append rejected`);\n    }\n    return this.append(...args.events);\n  }\n\n  at(path?: string): MemoryStream {\n    return path === undefined || this.network === undefined ? this : this.network.get(path);\n  }\n\n  async getEvent(\n    input: { offset: number } | { idempotencyKey: string },\n  ): Promise<StreamEvent | undefined> {\n    if (\"offset\" in input) return this.events.find((event) => event.offset === input.offset);\n    return this.events.find((event) => event.idempotencyKey === input.idempotencyKey);\n  }\n\n  async getEvents(input: StreamEventReadInput = {}): Promise<StreamEvent[]> {\n    const { afterOffset = 0, limit = 500 } = input;\n    const beforeOffset = input.beforeOffset ?? Number.MAX_SAFE_INTEGER;\n    const matching = this.events\n      .filter((event) => event.offset > afterOffset)\n      .filter((event) => event.offset < beforeOffset)\n      .filter(\n        (event) =>\n          input.eventTypes === undefined ||\n          input.eventTypes.includes(\"*\") ||\n          input.eventTypes.includes(event.type),\n      )\n      .slice(0, limit);\n    const byteLimit = input.byteLimit;\n    if (byteLimit === undefined) return matching;\n    let bytes = 0;\n    return matching.filter((event, index) => {\n      bytes += new TextEncoder().encode(JSON.stringify(event)).byteLength;\n      return bytes <= byteLimit || index === 0;\n    });\n  }\n\n  async getEventPage(input: StreamEventReadInput = {}) {\n    return {\n      streamId: this.streamId,\n      streamMaxOffset: this.events.at(-1)?.offset ?? 0,\n      events: await this.getEvents(input),\n    };\n  }\n\n  readEvents(input: StreamEventReadInput = {}) {\n    let afterOffset = input.afterOffset ?? 0;\n    return {\n      next: async () => {\n        const page = await this.getEvents({ ...input, afterOffset });\n        afterOffset = page.at(-1)?.offset ?? afterOffset;\n        return page;\n      },\n      [Symbol.dispose]() {},\n    };\n  }\n\n  async waitForEvent(input: {\n    afterOffset?: number;\n    eventTypes?: readonly string[];\n    predicate?: (event: StreamEvent) => boolean | Promise<boolean>;\n    timeoutMs: number;\n  }): Promise<StreamEvent> {\n    const deadline = Date.now() + input.timeoutMs;\n    while (Date.now() < deadline) {\n      for (const event of this.events) {\n        if (input.afterOffset !== undefined && event.offset <= input.afterOffset) continue;\n        if (input.eventTypes !== undefined && !input.eventTypes.includes(event.type)) continue;\n        if (input.predicate !== undefined && !(await input.predicate(event))) continue;\n        return event;\n      }\n      await new Promise((resolve) => setTimeout(resolve, 10));\n    }\n    throw new Error(\"Timed out waiting for event\");\n  }\n\n  async getProcessorRuntimeState(): Promise<null> {\n    return null;\n  }\n\n  async runtimeState() {\n    return emptyStreamRuntimeState();\n  }\n}\n\n/**\n * In-memory network of streams keyed by path, so router tests can observe\n * the cross-stream forwards (`stream.at(path).append(...)`) next to\n * same-stream appends. `now` feeds every member stream's createdAt stamp, so\n * freshness checks (such as webhook acknowledgement horizons) can be tested on both sides\n * of the horizon. `eventsAt` never creates a stream — `network.streams.size`\n * assertions (\"nothing was forwarded anywhere\") stay honest.\n */\nexport class MemoryStreamNetwork {\n  readonly streams = new Map<string, MemoryStream>();\n  readonly now: () => number;\n\n  constructor(now: () => number = Date.now) {\n    this.now = now;\n  }\n\n  get(path: string): MemoryStream {\n    let stream = this.streams.get(path);\n    if (stream === undefined) {\n      stream = new MemoryStream(path);\n      stream.network = this;\n      stream.now = this.now;\n      this.streams.set(path, stream);\n    }\n    return stream;\n  }\n\n  eventsAt(path: string): StreamEvent[] {\n    return this.streams.get(path)?.events ?? [];\n  }\n}\n\n// =============================================================================\n// Step harness: scenario tests as ordered steps over a durable substrate.\n// =============================================================================\n\n/**\n * One scenario step. Three built-in kinds plus a function escape hatch:\n *\n * - `[\"append\", ...events]` — typed appends (the contract's `consumes`\n *   vocabulary: what the outside world can put on this processor's stream);\n * - `[\"advanceTime\", ms]` — move the virtual clock, releasing any harness\n *   `sleep(...)` calls that come due;\n * - `[\"crash\"]` — abandon the incarnation like an eviction (runtime state and\n *   pending closures die; stream, progress, and clock survive);\n * - `async () => ...` — anything processor-specific (resolve a fake transport,\n *   assert mid-scenario).\n *\n * After every step the harness drives delivery to a fixpoint, so each step\n * observes the stream consequences of the previous one.\n */\nexport type HarnessStep<Contract extends StreamProcessorContract> =\n  | readonly [\"append\", ...ConsumedInput<Contract>[]]\n  | readonly [\"advanceTime\", number]\n  | readonly [\"crash\"]\n  | (() => unknown);\n\n/** The durable substrate shared across incarnations (and zombie twins). */\nexport type HarnessSubstrate = {\n  clock: { now: number };\n  stream: MemoryStream;\n  progress: ProcessorProgressStore<unknown>;\n};\n\ntype HarnessDurabilitySubstrate = {\n  storage: DurableObjectStorage;\n  alarm: { at: number | null };\n};\n\nconst durabilitySubstrates = new WeakMap<HarnessSubstrate, HarnessDurabilitySubstrate>();\nconst progressSubstrates = new WeakMap<object, HarnessDurabilitySubstrate>();\n\nfunction makeDurabilitySubstrate(): HarnessDurabilitySubstrate {\n  const kv = new Map<string, unknown>();\n  // `null as number | null` widens the literal so later `alarm.at = 123`\n  // assignments typecheck — an annotated `let` can't live in an object field.\n  const alarm = { at: null as number | null };\n  const storage = {\n    kv: {\n      // The map stores whatever the caller `put` under the key; `get<T>`\n      // mirrors the platform API's caller-asserted typing (the real\n      // DurableObjectStorage.kv.get is exactly this trust), so the cast\n      // restates the platform contract, not a new claim.\n      get: <T = unknown>(key: string): T | undefined =>\n        kv.has(key) ? (structuredClone(kv.get(key)) as T) : undefined,\n      put: (key: string, value: unknown) => void kv.set(key, structuredClone(value)),\n      delete: (key: string) => kv.delete(key),\n    },\n    getAlarm: async () => alarm.at,\n    setAlarm: async (at: number) => {\n      alarm.at = at;\n    },\n    deleteAlarm: async () => {\n      alarm.at = null;\n    },\n    // Double assertion because this implements only the members the keepalive\n    // and progress adapters touch (kv get/put/delete, get/set/deleteAlarm) — the\n    // platform type's dozens of other members (sql, transactions, bookmarks)\n    // are structurally missing on purpose. Safe for every consumer HERE\n    // because the adapters' member usage is pinned by these suites; a new\n    // adapter dependency would throw undefined-is-not-a-function loudly.\n  } as unknown as DurableObjectStorage;\n  return { storage, alarm };\n}\n\n/** What {@link makeProcessorHarness}'s factory receives: base deps plus the\n * harness's virtual clock/sleep, for processors that take injectable time. */\nexport type HarnessProcessorDeps<Contract extends StreamProcessorContract> = {\n  stream: ProcessorStream;\n  path: string;\n  projectId: string | null;\n  now: () => number;\n  sleep: (ms: number) => Promise<void>;\n  reads: Pick<RegisteredProcessorReads<ProcessorState<Contract>>, \"snapshot\" | \"waitUntilEvent\">;\n};\n\nexport type ProcessorHarness<\n  Contract extends StreamProcessorContract,\n  Processor extends StreamProcessor<Contract, object> = StreamProcessor<Contract, object>,\n> = {\n  clock: { now: number };\n  stream: MemoryStream;\n  substrate: HarnessSubstrate;\n  /** The current incarnation's runner, for tests that need its full surface.\n   * A method (not a property) so suites can spread the harness into a wider\n   * object without freezing a pre-crash incarnation. */\n  runner(): StreamProcessorRunner<Contract>;\n  /** The current incarnation's processor instance. */\n  processor(): Processor;\n  /** Run steps in order, driving delivery to a fixpoint after each. */\n  play(...steps: HarnessStep<Contract>[]): Promise<void>;\n  /** Typed append (the contract's `consumes` vocabulary) + drive to fixpoint. */\n  append(...events: ConsumedInput<Contract>[]): Promise<void>;\n  /** Advance the virtual clock, release due sleeps, drive to fixpoint. */\n  advanceTime(ms: number): Promise<void>;\n  /** Abandon this incarnation like an eviction; a fresh one takes over the\n   * same stream/progress/clock. Does NOT deliver — the successor first acts\n   * on the next step, exactly like a real revival. */\n  crash(): void;\n  /** Drive delivery to a fixpoint: repeated catch-up passes (with microtask\n   * drains between them, so settled background work can land its appends)\n   * until the stream head stops moving. */\n  settle(): Promise<void>;\n  /** The runner's committed reduced state. */\n  state(): ProcessorState<Contract>;\n  /** All committed stream rows. */\n  events(): StreamEvent[];\n  /** Committed rows of one event type, typed when the contract resolves it. */\n  events<Type extends string>(type: Type): ResolvedEvent<Contract, Type>[];\n};\n\n/** In-memory {@link ProcessorProgressStore} with the DO store's fencing check,\n * so progress survives `crash()` into the successor incarnation. Exported so\n * suites can hand a harness a FRESH store over an existing stream — a full\n * replay from offset zero, which is both the re-reduce-from-scratch recipe and the harshest\n * at-least-once redelivery test (every per-event append re-runs).\n *\n * The contract is required because progress and recovery share the same\n * per-processor Durable Object keys. A generic placeholder slug would let the\n * runner commit progress under one key while recovery looks under another.\n */\nexport function makeMemoryProgressStore(\n  contract: Pick<StreamProcessorContract, \"slug\">,\n): ProcessorProgressStore<unknown> {\n  const durability = makeDurabilitySubstrate();\n  const progress = durableObjectProgressStore<unknown>({\n    storage: durability.storage,\n    name: contract.slug,\n  });\n  progressSubstrates.set(progress, durability);\n  return progress;\n}\n\n/**\n * Build a {@link ProcessorHarness}: the real runner, ProcessorKeepalive, and\n * Durable Object durability adapters over an in-memory stream/KV/alarm\n * substrate. `crash()` is eviction: delivery stays detached until a new\n * append wakes it or a due keepalive alarm appends the revival fact. Pass\n * another harness's `substrate` to run a second incarnation over the same\n * durable state (the zombie-race setup).\n *\n * Appends commit synchronously unless a suite opts out through\n * `harness.stream.holdAppend` — the one seam for reproducing a processor that\n * appends the same lane from two places and orders only one of them.\n */\nexport function makeProcessorHarness<\n  Contract extends StreamProcessorContract,\n  Processor extends StreamProcessor<Contract, object> = StreamProcessor<Contract, object>,\n>(args: {\n  createProcessor: (deps: HarnessProcessorDeps<Contract>) => Processor;\n  path?: string;\n  substrate?: HarnessSubstrate;\n}): ProcessorHarness<Contract, Processor> {\n  const path = args.substrate?.stream.path ?? args.path ?? \"/harness/processor\";\n  const clock = args.substrate?.clock ?? { now: 1_000_000 };\n  const stream = args.substrate?.stream ?? new MemoryStream(path);\n  stream.now = () => clock.now;\n  const inheritedDurability =\n    args.substrate === undefined\n      ? undefined\n      : (durabilitySubstrates.get(args.substrate) ??\n        progressSubstrates.get(args.substrate.progress));\n  const durability = inheritedDurability ?? makeDurabilitySubstrate();\n\n  // The substrate stores progress as `<unknown>` so one substrate type serves\n  // every contract; the narrowing is safe because a substrate is only ever\n  // shared between incarnations of the SAME processor (the zombie-race\n  // setup), so the state it holds is this contract's. TypeScript cannot carry\n  // the contract through the untyped substrate hand-off.\n  let progress = args.substrate?.progress as\n    | ProcessorProgressStore<ProcessorState<Contract>>\n    | undefined;\n  let pendingSleeps: { dueAt: number; resolve: () => void }[] = [];\n  const releaseDueSleeps = () => {\n    const due = pendingSleeps.filter((sleep) => sleep.dueAt <= clock.now);\n    pendingSleeps = pendingSleeps.filter((sleep) => sleep.dueAt > clock.now);\n    for (const sleep of due) sleep.resolve();\n    return due.length;\n  };\n\n  let processor!: Processor;\n  let runner!: StreamProcessorRunner<Contract>;\n  let recovery!: ReturnType<typeof durableObjectRecovery>;\n  let incarnation = 0;\n  let deliveryEnabled = true;\n  let deliveryAttempt: Promise<void> | undefined;\n  let deliveryError: unknown;\n\n  const keepAlive = (work: Promise<unknown>) => {\n    void work.catch(() => undefined);\n  };\n  const incarnate = () => {\n    processor = args.createProcessor({\n      stream,\n      path,\n      projectId: \"proj_harness\",\n      now: () => clock.now,\n      sleep: (ms) =>\n        new Promise<void>((resolve) => pendingSleeps.push({ dueAt: clock.now + ms, resolve })),\n      reads: {\n        snapshot: () => runner.snapshot(),\n        waitUntilEvent: (input) =>\n          \"offset\" in input ? runner.waitUntilEvent(input) : runner.waitUntilEvent(input),\n      },\n    });\n    progress ??= durableObjectProgressStore<ProcessorState<Contract>>({\n      storage: durability.storage,\n      name: processor.contract.slug,\n    });\n    recovery = durableObjectRecovery({\n      storage: durability.storage,\n      name: processor.contract.slug,\n      stream,\n      version: \"test-harness\",\n      armAlarm: (atMs) => {\n        if (atMs === null) void durability.storage.deleteAlarm();\n        else void durability.storage.setAlarm(atMs);\n      },\n      waitUntil: keepAlive,\n      now: () => clock.now,\n    });\n    runner = new StreamProcessorRunner({\n      processor,\n      stream,\n      durability: { progress, recovery },\n      keepAlive: (work) => keepAlive(work()),\n      now: () => clock.now,\n      readPageSize: 5,\n    });\n  };\n  incarnate();\n\n  const substrate: HarnessSubstrate = {\n    clock,\n    stream,\n    // Inverse of the narrowing above: the substrate's public face erases the\n    // contract (stores are invariant in their state parameter, so neither\n    // direction is assignable without the assertion pair).\n    progress: progress as ProcessorProgressStore<unknown>,\n  };\n  if (args.substrate !== undefined) durabilitySubstrates.set(args.substrate, durability);\n  durabilitySubstrates.set(substrate, durability);\n  progressSubstrates.set(substrate.progress, durability);\n\n  const startDelivery = () => {\n    if (deliveryAttempt !== undefined) return;\n    const deliveryIncarnation = incarnation;\n    const attempt = runner.catchUp();\n    deliveryAttempt = attempt;\n    void attempt.then(\n      () => {\n        if (deliveryIncarnation === incarnation) deliveryAttempt = undefined;\n      },\n      (error: unknown) => {\n        if (deliveryIncarnation !== incarnation) return;\n        deliveryAttempt = undefined;\n        deliveryError = error;\n      },\n    );\n  };\n\n  const settle = async () => {\n    // Fixpoint with a bounded round count: each round drains real microtasks\n    // and macrotasks so background work can append, then catches the runner up.\n    let quietRounds = 0;\n    let lastAppendedTypes: string[] = [];\n    for (let round = 0; round < 50; round++) {\n      const headBefore = stream.events.at(-1)?.offset ?? 0;\n      const releasedSleeps = releaseDueSleeps();\n      if (deliveryEnabled) startDelivery();\n      await new Promise((resolve) => setTimeout(resolve, 0));\n      if (deliveryError !== undefined) {\n        const error = deliveryError;\n        deliveryError = undefined;\n        throw error;\n      }\n      const headAfter = stream.events.at(-1)?.offset ?? 0;\n      lastAppendedTypes = stream.events\n        .filter((event) => event.offset > headBefore)\n        .map((event) => event.type);\n      quietRounds = headAfter === headBefore && releasedSleeps === 0 ? quietRounds + 1 : 0;\n      // An alarm-backed attempt may be intentionally hung so the next crash\n      // can evict it. Once the stream is quiet and its durable recovery alarm\n      // is armed, that parked attempt is a stable scenario boundary.\n      if (\n        quietRounds === 3 &&\n        (!deliveryEnabled || deliveryAttempt === undefined || durability.alarm.at !== null)\n      ) {\n        return;\n      }\n    }\n    const headOffset = stream.events.at(-1)?.offset ?? 0;\n    throw new Error(\n      `harness settle() did not reach a fixpoint in 50 rounds; ` +\n        `last round appended event types: ${lastAppendedTypes.join(\", \") || \"none\"}; ` +\n        `head offset: ${headOffset}`,\n    );\n  };\n\n  const append = async (...events: ConsumedInput<Contract>[]) => {\n    // A consumed input IS a stream event input — the contract type only\n    // narrows `type`/`payload` to the consumed vocabulary. TypeScript cannot\n    // relate the distributive contract-derived union back to the plain input\n    // shape, so the widening is asserted.\n    await stream.append(...(events as StreamEventInput[]));\n    deliveryEnabled = true;\n    await settle();\n  };\n\n  const advanceTime = async (ms: number) => {\n    const target = clock.now + ms;\n    while (durability.alarm.at !== null && durability.alarm.at <= target) {\n      clock.now = Math.max(clock.now, durability.alarm.at);\n      durability.alarm.at = null;\n      await recovery.handleAlarm();\n      deliveryEnabled = true;\n      await settle();\n    }\n    clock.now = target;\n    await settle();\n  };\n\n  const crash = () => {\n    runner.dispose();\n    incarnation += 1;\n    deliveryEnabled = false;\n    deliveryAttempt = undefined;\n    deliveryError = undefined;\n    pendingSleeps = [];\n    incarnate();\n  };\n\n  return {\n    clock,\n    stream,\n    substrate,\n    runner: () => runner,\n    processor: () => processor,\n    append,\n    advanceTime,\n    crash,\n    settle,\n    state: () => runner.currentState,\n    // TypeScript cannot check an implementation arrow against an overload\n    // pair, so the assertion is unavoidable. Soundness is the same claim the\n    // typed read surface makes everywhere: rows filtered to `type` carry that\n    // type's contract payload — committed rows are trusted, not re-parsed,\n    // exactly like production reads.\n    events: ((type?: string) =>\n      type === undefined\n        ? [...stream.events]\n        : stream.events.filter((row) => row.type === type)) as ProcessorHarness<\n      Contract,\n      Processor\n    >[\"events\"],\n    async play(...steps: HarnessStep<Contract>[]) {\n      for (const [index, step] of steps.entries()) {\n        const kind = typeof step === \"function\" ? \"function\" : step[0];\n        try {\n          if (typeof step === \"function\") {\n            await step();\n            await settle();\n          } else if (step[0] === \"append\") {\n            const [, ...events] = step;\n            await append(...events);\n          } else if (step[0] === \"advanceTime\") {\n            await advanceTime(step[1]);\n          } else {\n            crash();\n          }\n        } catch (error) {\n          throw new Error(`harness play() step ${index} (${kind}) failed`, { cause: error });\n        }\n      }\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/processors.mjs

@@ -1,52 +0,0 @@
-import { A as resolveStreamPath, C as StreamListItem, D as StreamRuntimeMetrics, E as MinuteBuckets, F as isStreamIdMismatchError, I as isStreamOffsetConflictError, L as isStreamReceiverUnavailableError, M as StreamIdMismatchError, N as StreamOffsetConflictError, O as ageStreamThroughputMetrics, P as StreamReceiverUnavailableError, R as streamIdMismatchMessage, S as StreamEventInput, T as LatencyRing, _ as getEventInputSchema, a as revivalBackoffMs, b as MAX_COPIED_FROM_HOPS, c as awaitKeepAliveBacked, d as STREAM_PROCESSOR_REVIVED_EVENT_TYPE, f as assertObjectProcessorState, g as getConsumedEventDefinition, h as defineProcessorContract, i as REVIVAL_BACKOFF_PLATEAU_MS, j as MAX_STREAM_EVENT_READ_BYTE_LIMIT, k as pingRoundTrip, l as PLATFORM_STREAM_EVENTS, m as cachedEventSchema, n as MAX_CONSECUTIVE_BUSY_REFIRES, o as StreamProcessorRunner, p as buildEvent, r as ProcessorKeepalive, s as StreamProcessor, t as KEEPALIVE_ALARM_LEAD_MS, u as ProcessorContractAnnouncement, v as getResolvedEventDefinition, w as EventConsumptionMetrics, x as StreamEvent, y as mergeProcessorConfig, z as streamOffsetConflictMessage } from "./stream-processor-keepalive-DAQTP6m3.mjs";
-import { n as hostRuntimeCapabilities, t as announceContract } from "./processor-host-capabilities-BMFH3KTM.mjs";
-import { i as sameIdempotentEvent, n as isIdempotencyConflict, r as jsonValuesEqual, t as idempotencyConflictMessage } from "./idempotency-DleloJNt.mjs";
-//#region src/processors/prompt-sections.ts
-const SECTION_OPEN_TAG = /<section key="([^"<>]+)">/g;
-/**
-* Parse a prompt file's authoring syntax into sections, in file order.
-* Content inside `<section key="x">...</section>` becomes a section with
-* that key; content outside any tag (including a whole untagged file)
-* becomes a section with `fallbackKey` — so an untagged prompt file parses
-* to one section and keeps working unchanged. Throws on malformed authoring
-* (unclosed or nested tags): this runs at append time, where a loud failure
-* beats silently shipping tag soup to a model.
-*/
-function parsePromptSections(input) {
-	const sections = [];
-	const pushFallback = (raw) => {
-		const content = raw.trim();
-		if (content !== "") sections.push({
-			key: input.fallbackKey,
-			content
-		});
-	};
-	let cursor = 0;
-	SECTION_OPEN_TAG.lastIndex = 0;
-	for (;;) {
-		const open = SECTION_OPEN_TAG.exec(input.content);
-		if (open === null) break;
-		pushFallback(input.content.slice(cursor, open.index));
-		const bodyStart = open.index + open[0].length;
-		const close = input.content.indexOf("</section>", bodyStart);
-		if (close < 0) throw new Error(`unclosed <section key="${open[1]}"> in prompt file`);
-		const body = input.content.slice(bodyStart, close);
-		if (body.includes("<section ")) throw new Error(`nested <section> inside <section key="${open[1]}"> — sections are flat`);
-		sections.push({
-			key: open[1],
-			content: body.trim()
-		});
-		cursor = close + 10;
-		SECTION_OPEN_TAG.lastIndex = cursor;
-	}
-	pushFallback(input.content.slice(cursor));
-	if (sections.length === 0) sections.push({
-		key: input.fallbackKey,
-		content: ""
-	});
-	return sections;
-}
-//#endregion
-export { EventConsumptionMetrics, KEEPALIVE_ALARM_LEAD_MS, LatencyRing, MAX_CONSECUTIVE_BUSY_REFIRES, MAX_COPIED_FROM_HOPS, MAX_STREAM_EVENT_READ_BYTE_LIMIT, MinuteBuckets, PLATFORM_STREAM_EVENTS, ProcessorContractAnnouncement, ProcessorKeepalive, REVIVAL_BACKOFF_PLATEAU_MS, STREAM_PROCESSOR_REVIVED_EVENT_TYPE, StreamEvent, StreamEventInput, StreamIdMismatchError, StreamListItem, StreamOffsetConflictError, StreamProcessor, StreamProcessorRunner, StreamReceiverUnavailableError, StreamRuntimeMetrics, ageStreamThroughputMetrics, announceContract, assertObjectProcessorState, awaitKeepAliveBacked, buildEvent, cachedEventSchema, defineProcessorContract, getConsumedEventDefinition, getEventInputSchema, getResolvedEventDefinition, hostRuntimeCapabilities, idempotencyConflictMessage, isIdempotencyConflict, isStreamIdMismatchError, isStreamOffsetConflictError, isStreamReceiverUnavailableError, jsonValuesEqual, mergeProcessorConfig, parsePromptSections, pingRoundTrip, resolveStreamPath, revivalBackoffMs, sameIdempotentEvent, streamIdMismatchMessage, streamOffsetConflictMessage };
-
-//# sourceMappingURL=processors.mjs.map

package/dist/processors.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"processors.mjs","names":[],"sources":["../src/processors/prompt-sections.ts"],"sourcesContent":["// The append-time authoring parser for sectionized prompt files (design:\n// tasks/prompt-sections-tree.md and docs/prompt-sections-demo.html): authors\n// write ONE file with `<section key=\"...\">` tags; the APPENDING code parses\n// it once into a list of {key, content} sections it maps to keyed\n// context-added events — one per section, committed in a single atomic\n// batch, so file order becomes offset order becomes document order, and\n// every later change addresses a section by re-adding its key. Nothing ever\n// parses model-visible strings again. The tags are the SAME syntax the fold\n// renders the standing document with, so an unforked file round-trips\n// byte-identically. Shared between the platform (agent birth defaults) and\n// config-repo template workers, which is why it lives in the iterate\n// package rather than apps/os.\n\nexport type PromptSection = { key: string; content: string };\n\nconst SECTION_OPEN_TAG = /<section key=\"([^\"<>]+)\">/g;\n\n/**\n * Parse a prompt file's authoring syntax into sections, in file order.\n * Content inside `<section key=\"x\">...</section>` becomes a section with\n * that key; content outside any tag (including a whole untagged file)\n * becomes a section with `fallbackKey` — so an untagged prompt file parses\n * to one section and keeps working unchanged. Throws on malformed authoring\n * (unclosed or nested tags): this runs at append time, where a loud failure\n * beats silently shipping tag soup to a model.\n */\nexport function parsePromptSections(input: {\n  content: string;\n  fallbackKey: string;\n}): PromptSection[] {\n  const sections: PromptSection[] = [];\n  const pushFallback = (raw: string) => {\n    const content = raw.trim();\n    if (content !== \"\") sections.push({ key: input.fallbackKey, content });\n  };\n  let cursor = 0;\n  SECTION_OPEN_TAG.lastIndex = 0;\n  for (;;) {\n    const open = SECTION_OPEN_TAG.exec(input.content);\n    if (open === null) break;\n    pushFallback(input.content.slice(cursor, open.index));\n    const bodyStart = open.index + open[0].length;\n    const close = input.content.indexOf(\"</section>\", bodyStart);\n    if (close < 0) {\n      throw new Error(`unclosed <section key=\"${open[1]}\"> in prompt file`);\n    }\n    const body = input.content.slice(bodyStart, close);\n    if (body.includes(\"<section \")) {\n      throw new Error(`nested <section> inside <section key=\"${open[1]}\"> — sections are flat`);\n    }\n    sections.push({ key: open[1]!, content: body.trim() });\n    cursor = close + \"</section>\".length;\n    SECTION_OPEN_TAG.lastIndex = cursor;\n  }\n  pushFallback(input.content.slice(cursor));\n  if (sections.length === 0) {\n    // An empty (or whitespace-only) file still parses: one empty fallback\n    // segment, so a keyed supersession with empty content stays expressible.\n    sections.push({ key: input.fallbackKey, content: \"\" });\n  }\n  return sections;\n}\n"],"mappings":";;;;AAeA,MAAM,mBAAmB;;;;;;;;;;AAWzB,SAAgB,oBAAoB,OAGhB;CAClB,MAAM,WAA4B,CAAC;CACnC,MAAM,gBAAgB,QAAgB;EACpC,MAAM,UAAU,IAAI,KAAK;EACzB,IAAI,YAAY,IAAI,SAAS,KAAK;GAAE,KAAK,MAAM;GAAa;EAAQ,CAAC;CACvE;CACA,IAAI,SAAS;CACb,iBAAiB,YAAY;CAC7B,SAAS;EACP,MAAM,OAAO,iBAAiB,KAAK,MAAM,OAAO;EAChD,IAAI,SAAS,MAAM;EACnB,aAAa,MAAM,QAAQ,MAAM,QAAQ,KAAK,KAAK,CAAC;EACpD,MAAM,YAAY,KAAK,QAAQ,KAAK,EAAE,CAAC;EACvC,MAAM,QAAQ,MAAM,QAAQ,QAAQ,cAAc,SAAS;EAC3D,IAAI,QAAQ,GACV,MAAM,IAAI,MAAM,0BAA0B,KAAK,GAAG,kBAAkB;EAEtE,MAAM,OAAO,MAAM,QAAQ,MAAM,WAAW,KAAK;EACjD,IAAI,KAAK,SAAS,WAAW,GAC3B,MAAM,IAAI,MAAM,yCAAyC,KAAK,GAAG,uBAAuB;EAE1F,SAAS,KAAK;GAAE,KAAK,KAAK;GAAK,SAAS,KAAK,KAAK;EAAE,CAAC;EACrD,SAAS,QAAQ;EACjB,iBAAiB,YAAY;CAC/B;CACA,aAAa,MAAM,QAAQ,MAAM,MAAM,CAAC;CACxC,IAAI,SAAS,WAAW,GAGtB,SAAS,KAAK;EAAE,KAAK,MAAM;EAAa,SAAS;CAAG,CAAC;CAEvD,OAAO;AACT"}