iterate 0.2.7 → 0.3.0

package/dist/starter-apps/guestbook/worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.mjs","names":["#ensureInitialized","guestbookClientSource","RpcTarget","#app","#liveState"],"sources":["../../../src/starter-apps/guestbook/processor.ts","../../../src/starter-apps/guestbook/worker.ts"],"sourcesContent":["// The guestbook's stream processor: it folds the signatures on the project\n// stream at /guestbook into a birth certificate plus an append-only list of\n// entries. The reduce is the whole processor — pure fold, no side effects.\nimport { z } from \"zod\";\nimport { defineProcessorContract, StreamProcessor } from \"../../processors/index.ts\";\nimport type { ProcessorState, ReduceArgs } from \"../../processors/index.ts\";\n\nexport const GuestbookProcessorContract = defineProcessorContract({\n  slug: \"guestbook\",\n  version: \"0.1.0\",\n  description: \"Reduces guestbook signatures on /guestbook.\",\n  stateSchema: z.object({\n    birthCertificate: z\n      .object({\n        config: z.object({\n          title: z.string().meta({ description: \"Display title shown on the public page.\" }),\n        }),\n      })\n      .nullable()\n      .default(null)\n      .meta({\n        description: \"Existence marker: null until guestbook/created reduces. Signing requires it.\",\n      }),\n    entries: z\n      .array(\n        z.object({\n          name: z.string().meta({ description: \"Signer display name.\" }),\n          message: z.string().meta({ description: \"Note left by the signer.\" }),\n          signedAt: z\n            .string()\n            .meta({ description: \"ISO-8601 time from the stream event createdAt.\" }),\n        }),\n      )\n      .default([])\n      .meta({ description: \"Signatures in stream order (oldest first).\" }),\n  }),\n  events: {\n    \"events.iterate.com/guestbook/created\": {\n      description:\n        \"The guestbook exists: its birth certificate, the first event in its domain history. \" +\n        \"Appended (idempotency-keyed) by whoever signs first or opens the API.\",\n      payloadSchema: z.object({\n        config: z\n          .object({\n            title: z.string().meta({ description: \"Display title for the guestbook.\" }),\n          })\n          .meta({ description: \"Initial configuration.\" }),\n      }),\n      examples: [\n        {\n          description: \"A guestbook born with its display title.\",\n          payload: { config: { title: \"Guestbook\" } },\n        },\n      ],\n    },\n    \"events.iterate.com/guestbook/entry-signed\": {\n      description: \"Someone signed the guestbook: their name and message.\",\n      payloadSchema: z.object({\n        name: z.string().trim().min(1).meta({ description: \"Signer display name.\" }),\n        message: z.string().trim().min(1).meta({ description: \"Note left by the signer.\" }),\n      }),\n      examples: [\n        {\n          description: \"A visitor left a note.\",\n          payload: { name: \"Ada\", message: \"Lovely worker you have here.\" },\n        },\n      ],\n    },\n  },\n  consumes: [\"events.iterate.com/guestbook/created\", \"events.iterate.com/guestbook/entry-signed\"],\n  emits: [],\n});\nexport type GuestbookProcessorContract = typeof GuestbookProcessorContract;\n\nexport type GuestbookState = ProcessorState<GuestbookProcessorContract>;\n\nexport class GuestbookProcessor extends StreamProcessor<GuestbookProcessorContract> {\n  readonly contract = GuestbookProcessorContract;\n\n  protected override reduce({ event, state }: ReduceArgs<GuestbookProcessorContract>) {\n    switch (event.type) {\n      case \"events.iterate.com/guestbook/created\":\n        // Idempotency-keyed at the source, but a duplicate that slips through\n        // folds to a no-op rather than wedging the frame.\n        if (state.birthCertificate !== null) return state;\n        return { ...state, birthCertificate: event.payload };\n      case \"events.iterate.com/guestbook/entry-signed\":\n        return {\n          ...state,\n          entries: [...state.entries, { ...event.payload, signedAt: event.createdAt }],\n        };\n      default:\n        return state;\n    }\n  }\n}\n","/// <reference path=\"./virtual-client.d.ts\" />\nimport guestbookClientSource from \"iterate:guestbook-client-source\";\nimport {\n  LiveStateRpcTarget,\n  RpcTarget,\n  newWorkersWebSocketRpcResponse,\n  type LiveStateRpc,\n} from \"../../sdk/capnweb/index.ts\";\nimport type { StreamProcessorRegistry } from \"../../processors/cloudflare.ts\";\nimport {\n  StreamProcessorDurableObject,\n  type ProcessorHostDeps,\n  type StreamEvent,\n} from \"../../sdk.ts\";\nimport { guestbookCreationEvents, guestbookStreamPath } from \"./app-ref.ts\";\nimport { GuestbookProcessor, type GuestbookState } from \"./processor.ts\";\n\n/** One packaged Durable Object owns the page, API, processor, and live value.\n * `alarm()`, the `processor` wake door, `snapshot()`, and `registry()` come\n * from {@link StreamProcessorDurableObject}; all this class writes is how to\n * build its processor plus its own HTTP + append verbs. */\nexport class GuestbookApp extends StreamProcessorDurableObject<GuestbookState> {\n  protected readonly streamPath = guestbookStreamPath;\n  protected createProcessor(deps: ProcessorHostDeps) {\n    return new GuestbookProcessor(deps);\n  }\n\n  /** Lazily initialize the stream. The idempotency-keyed creation fact may be\n   * offered by every caller. */\n  async #ensureInitialized(): Promise<StreamProcessorRegistry<GuestbookState>> {\n    const registry = await this.registry();\n    await registry.catchUp(\"guestbook\");\n    using project = await this.env.ITX.get();\n    await project.streams.get(guestbookStreamPath).append(...guestbookCreationEvents());\n    await registry.catchUp(\"guestbook\");\n    return registry;\n  }\n\n  /** Project-worker event delivery calls this after a durable Guestbook event\n   * commits. Catch-up owns validation, ordering, checkpointing, and dedupe. */\n  async syncEvent(event: StreamEvent): Promise<void> {\n    if (event.path !== guestbookStreamPath) return;\n    const registry = await this.#ensureInitialized();\n    await registry.catchUp(\"guestbook\");\n    registry.refreshLive();\n  }\n\n  /** Internal worker RPC surface used to verify source upgrades and delivery. */\n  async getState(): Promise<GuestbookState> {\n    await this.#ensureInitialized();\n    return (await this.snapshot()).state;\n  }\n\n  async sign(name: string, message: string): Promise<void> {\n    const trimmedName = name.trim().slice(0, 80);\n    const trimmedMessage = message.trim().slice(0, 500);\n    if (trimmedName.length === 0 || trimmedMessage.length === 0) {\n      throw new TypeError(\"Name and message are required\");\n    }\n    const registry = await this.#ensureInitialized();\n    using project = await this.env.ITX.get();\n    await project.streams.get(guestbookStreamPath).append({\n      type: \"events.iterate.com/guestbook/entry-signed\",\n      payload: { message: trimmedMessage, name: trimmedName },\n      idempotencyKey: `guestbook/entry:${crypto.randomUUID()}`,\n    });\n    await registry.catchUp(\"guestbook\");\n    registry.refreshLive();\n  }\n\n  async fetch(request: Request): Promise<Response> {\n    const url = new URL(request.url);\n    if (url.pathname === \"/api\") {\n      const registry = await this.#ensureInitialized();\n      await registry.loadAndRefreshLive();\n      return newWorkersWebSocketRpcResponse(request, new GuestbookApi(this, registry));\n    }\n    if (request.method === \"GET\" && url.pathname === \"/apps/guestbook/client.js\") {\n      return new Response(guestbookClientSource, {\n        headers: {\n          \"content-type\": \"application/javascript; charset=utf-8\",\n          \"x-content-type-options\": \"nosniff\",\n        },\n      });\n    }\n    if (request.method !== \"GET\" || url.pathname !== \"/\") {\n      return new Response(\"not found\", { status: 404 });\n    }\n    return new Response(\n      `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\">\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n    <title>Guestbook</title>\n    <style>\n      :root { color-scheme: light dark; font-family: system-ui, sans-serif; }\n      body { margin: 0; padding: 2rem; }\n      main { margin: 0 auto; max-width: 38rem; }\n      form { display: grid; gap: .75rem; }\n      input, textarea, button { font: inherit; padding: .6rem; }\n      article { border-block-start: 1px solid #8886; margin-block-start: 1.25rem; padding-block-start: 1rem; }\n      time { opacity: .65; }\n      [role=\"alert\"] { color: #c33; }\n    </style>\n  </head>\n  <body>\n    <main id=\"root\"><p>Loading…</p></main>\n    <script type=\"module\" src=\"/apps/guestbook/client.js\"></script>\n  </body>\n</html>`,\n      {\n        headers: {\n          \"content-type\": \"text/html; charset=utf-8\",\n          \"x-content-type-options\": \"nosniff\",\n        },\n      },\n    );\n  }\n}\n\nexport class GuestbookApi extends RpcTarget {\n  readonly #app: GuestbookApp;\n  readonly #liveState: LiveStateRpcTarget<GuestbookState>;\n\n  constructor(app: GuestbookApp, registry: StreamProcessorRegistry<GuestbookState>) {\n    super();\n    this.#app = app;\n    this.#liveState = new LiveStateRpcTarget(registry);\n  }\n\n  get liveState(): LiveStateRpc<GuestbookState> {\n    return this.#liveState;\n  }\n\n  async sign(name: string, message: string): Promise<void> {\n    await this.#app.sign(name, message);\n  }\n}\n"],"mappings":"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"}

package/dist/starter-apps/media/configured-worker.mjs

@@ -0,0 +1,577 @@
+import { _ as object, f as array, g as number, l as defineProcessorContract, o as StreamProcessor, p as boolean, r as StreamProcessorDurableObject, t as _usingCtx, v as record, y as string } from "../../usingCtx-mZx5nsAW.mjs";
+import { t as isIdempotencyConflict } from "../../processors-BoNyeBfQ.mjs";
+//#region src/starter-apps/media/analysis.ts
+/** Sees the pixels: transcribes text verbatim and picks tags. */
+const MEDIA_VISION_MODEL = "@cf/meta/llama-4-scout-17b-16e-instruct";
+/**
+* Starter taxonomy — expect churn. Multi-tag with overlap allowed; the model
+* may also coin up to two novel kebab-case tags, and returning NO tags is an
+* acceptable answer (deliberately conservative — early dogfood tagged
+* everything `bug-report` on wild guesses).
+*/
+const MEDIA_TAG_TAXONOMY = [
+	{
+		tag: "screenshot",
+		hint: "a captured device screen: app UI, web page, status bar visible"
+	},
+	{
+		tag: "photo",
+		hint: "a camera photograph of the physical world"
+	},
+	{
+		tag: "transient",
+		hint: "one-off info with no lasting value: OTP codes, confirmations"
+	},
+	{
+		tag: "clipping",
+		hint: "a saved post, article, meme, or quote worth keeping"
+	},
+	{
+		tag: "logistics",
+		hint: "tickets, bookings, schedules, travel details, QR codes"
+	},
+	{
+		tag: "receipt",
+		hint: "proof of purchase, invoices, order confirmations"
+	},
+	{
+		tag: "conversation",
+		hint: "chat threads, DMs, emails, comment sections"
+	},
+	{
+		tag: "code",
+		hint: "code, terminals, dev tools, technical docs"
+	},
+	{
+		tag: "reference",
+		hint: "info to keep long-term: settings, lists, instructions"
+	}
+];
+/**
+* One full analysis of a stored media file. Throws on conversion failure so
+* the caller (the processor's obligation attempt) owns retry/settlement; an
+* unparseable vision answer degrades to empty title/transcript and
+* ["untagged"] so failures stay visible instead of hiding an item.
+*/
+async function analyzeMediaImage(session, input) {
+	const bytes = await session.files.get(input.path).bytes();
+	const described = await session.ai.toMarkdown({
+		name: input.filename,
+		blob: bytes
+	});
+	if (described.format === "error") throw new Error(`toMarkdown failed for ${input.filename}: ${described.error}`);
+	const markdown = (described.data || "").trim();
+	let visionBytes = bytes;
+	let visionType = input.contentType;
+	if (bytes.length > 1e6) try {
+		const resized = await session.integrations.cf.images.transformBytes({
+			image: bytes,
+			transforms: [{ width: 1280 }],
+			output: {
+				format: "image/jpeg",
+				quality: 80
+			}
+		});
+		visionBytes = resized.bytes;
+		visionType = resized.contentType;
+	} catch {}
+	let binary = "";
+	for (let i = 0; i < visionBytes.length; i += 32768) binary += String.fromCharCode(...visionBytes.subarray(i, i + 32768));
+	return {
+		...parseVisionAnswer(visionAnswerText(await session.ai.run(MEDIA_VISION_MODEL, {
+			messages: [{
+				role: "user",
+				content: [{
+					type: "text",
+					text: mediaVisionPrompt()
+				}, {
+					type: "image_url",
+					image_url: { url: `data:${visionType};base64,${btoa(binary)}` }
+				}]
+			}],
+			max_tokens: 1024
+		}))),
+		markdown
+	};
+}
+/** Both Workers AI answer shapes: `{ response }` and OpenAI-style choices. */
+function visionAnswerText(answer) {
+	const bag = answer;
+	if (typeof bag?.response === "string") return bag.response;
+	const content = bag?.choices?.[0]?.message?.content;
+	return typeof content === "string" ? content : "";
+}
+/** Extract the JSON object from a chatty model answer, defensively. */
+function parseVisionAnswer(text) {
+	let title = "";
+	let transcript = "";
+	let tags = ["untagged"];
+	const match = text.match(/\{[\s\S]*\}/);
+	if (match) try {
+		const parsed = JSON.parse(match[0]);
+		if (typeof parsed.title === "string") title = parsed.title.trim().slice(0, 120);
+		if (typeof parsed.transcript === "string") transcript = parsed.transcript.trim();
+		if (Array.isArray(parsed.tags)) tags = [...new Set(parsed.tags.filter((tag) => typeof tag === "string").map((tag) => tag.toLowerCase().trim().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "")).filter((tag) => tag.length > 0 && tag.length <= 30))].slice(0, 6);
+	} catch {}
+	return {
+		title,
+		transcript,
+		tags,
+		processedBy: MEDIA_VISION_MODEL
+	};
+}
+function mediaVisionPrompt() {
+	return [
+		"Reply with ONLY a JSON object: {\"title\": string, \"transcript\": string, \"tags\": string[]}.",
+		"title: ONE line saying what the image IS, specific not generic — 'Trenitalia ticket Rome→Florence 09:45', never 'Screenshot' or 'Image Description'.",
+		"transcript: ALL text visible in the image, verbatim, reading order. Empty string if there is none.",
+		"tags: pick from the list below. Include a tag ONLY when the image clearly shows it — no guesses.",
+		"Fewer tags is better; an empty array is a fine answer. Overlap is allowed.",
+		...MEDIA_TAG_TAXONOMY.map(({ tag, hint }) => `- "${tag}": ${hint}`),
+		"You may add at most 2 extra kebab-case tags if something important has no tag above."
+	].join("\n");
+}
+//#endregion
+//#region src/starter-apps/media/ref.ts
+const mediaStreamPath = "/media";
+//#endregion
+//#region src/starter-apps/media/processor.ts
+/**
+* An analysis obligation is abandoned (settled as failed, without dialing
+* the AI) when its requesting event is older than this — the staleness
+* doctrine's horizon. Generous on purpose: a phone can upload while the
+* analyzer is broken and still get analyzed when the fix deploys; Re-analyze
+* covers anything older.
+*/
+const MEDIA_ANALYSIS_EXPIRY_MS = 1440 * 60 * 1e3;
+/** Tries per attempt, with backoff between them — covers the transient
+* Workers AI failure class ("8005: Internal server error") observed in prod
+* without an extra durable event per retry. */
+const ANALYSIS_TRIES = 3;
+const ANALYSIS_RETRY_BACKOFF_MS = [2e3, 8e3];
+/**
+* Attempts started per caught-up pass, matching the phone's old 3-wide
+* pipeline. A 19-item Delete-all re-sync once fired 19 parallel vision
+* pipelines from one pass and Workers AI answered with 8004s and 60s
+* binding timeouts — the in-attempt retries all landed inside the same
+* overloaded burst. The rest of the queue needs no timer: every settlement
+* append comes back through this processor's own delivery and the next
+* caught-up pass starts the next wave.
+*/
+const MAX_CONCURRENT_ANALYSES = 3;
+const processingFields = {
+	title: string().default("").meta({ description: "One-line description of what the image IS (pre-title events fold to empty)." }),
+	markdown: string().meta({ description: "Vision-model description — half the search corpus." }),
+	transcript: string().meta({ description: "Verbatim OCR of visible text — the other half." }),
+	tags: array(string()).meta({ description: "Conservative multi-label tags." }),
+	processedBy: string().meta({ description: "Model id that produced this processing." })
+};
+const fileFields = {
+	stableKey: string().meta({ description: "Content hash — the item's identity." }),
+	path: string().meta({ description: "itx.files path holding the bytes." }),
+	filename: string().meta({ description: "Original filename as picked/synced." }),
+	contentType: string(),
+	width: number(),
+	height: number(),
+	source: string().default("picker").meta({ description: "\"picker\", \"library-sync\", or \"note\" (a note attachment)." }),
+	capturedAt: string().nullable().default(null).meta({ description: "Asset creation time (ISO) when the source knew it." }),
+	isScreenshot: boolean().nullable().default(null).meta({ description: "iOS mediaSubtypes screenshot flag." })
+};
+const MediaItem = object({
+	...fileFields,
+	capturedEventAt: string().meta({ description: "Stream time the capture committed." }),
+	...processingFields,
+	analysisError: string().nullable().default(null).meta({ description: "The latest analysis settlement's failure, or null. Rows born from media/uploaded exist regardless of analysis outcome; a terminal failure lands here." }),
+	settledRequestOffset: number().nullable().default(null).meta({ description: "requestOffset of the last APPLIED settlement — settlements apply monotonically, so a late one answering an older request can never overwrite a newer result (null until a requestOffset-carrying settlement lands; legacy settlements don't advance it)." })
+});
+const PendingAnalysis = object({
+	stableKey: string(),
+	path: string(),
+	filename: string(),
+	contentType: string(),
+	requestOffset: number().meta({ description: "Offset of the uploaded/reanalyze event that opened this obligation — the settlement's idempotency identity." }),
+	expiresAtMs: number().meta({ description: "Epoch ms (request createdAt + MEDIA_ANALYSIS_EXPIRY_MS); past it the obligation settles as expired without dialing the AI." })
+});
+const MediaProcessorContract = defineProcessorContract({
+	slug: "media",
+	version: "0.2.1",
+	description: "Reduces captured media (screenshots/photos) on /media into a searchable index, and drives server-side vision analysis of uploaded items (obligation pattern).",
+	stateSchema: object({
+		items: record(string(), MediaItem).default({}).meta({ description: "Items by stableKey, latest processing overlaid." }),
+		pendingAnalyses: record(string(), PendingAnalysis).default({}).meta({ description: "Open analysis obligations by stableKey (latest request wins); settled by one media/processed event each." })
+	}),
+	events: {
+		"events.iterate.com/media/uploaded": {
+			description: "A media item's bytes landed in project files: the phone appends this cheap durable fact right after files.put (metadata only — no analysis yet), idempotency-keyed by content hash + wipe generation, sharing the media/captured key scheme so an item already captured never re-uploads as a duplicate. Opens an analysis obligation.",
+			payloadSchema: object(fileFields),
+			examples: [{
+				description: "A synced screenshot, uploaded and awaiting analysis.",
+				payload: {
+					stableKey: "abc123",
+					path: "/media/abc123-IMG_0001.png",
+					filename: "IMG_0001.png",
+					contentType: "image/png",
+					width: 1170,
+					height: 2532,
+					source: "library-sync",
+					capturedAt: "2026-08-10T09:00:00.000Z",
+					isScreenshot: true
+				}
+			}]
+		},
+		"events.iterate.com/media/reanalyze-requested": {
+			description: "Re-analyze an existing item (the app's Re-analyze button): opens an analysis obligation for it; the settlement overlays the item's processing fields.",
+			payloadSchema: object({ stableKey: string() }),
+			examples: [{
+				description: "A user-requested re-run.",
+				payload: { stableKey: "abc123" }
+			}]
+		},
+		"events.iterate.com/media/captured": {
+			description: "LEGACY (pre media/uploaded): a media item entered the project with its first vision processing inline, appended by the old phone-driven capture script. Still folded so history keeps rendering; nothing appends it anymore.",
+			payloadSchema: object({
+				...fileFields,
+				...processingFields
+			}),
+			examples: [{
+				description: "A synced screenshot with its first processing.",
+				payload: {
+					stableKey: "abc123",
+					path: "/media/abc123-IMG_0001.png",
+					filename: "IMG_0001.png",
+					contentType: "image/png",
+					width: 1170,
+					height: 2532,
+					source: "library-sync",
+					capturedAt: "2026-08-10T09:00:00.000Z",
+					isScreenshot: true,
+					markdown: "A train ticket from Rome to Florence.",
+					transcript: "Trenitalia 09:45",
+					tags: ["screenshot", "logistics"],
+					processedBy: "@cf/meta/llama-4-scout-17b-16e-instruct"
+				}
+			}]
+		},
+		"events.iterate.com/media/wiped": {
+			description: "Everything before this tombstone is gone: the wipe script deleted the stored files and every derivation (phone list, this fold) resets. Deliberate per-invocation idempotency key.",
+			payloadSchema: object({
+				deletedFiles: number().meta({ description: "Files actually deleted." }),
+				items: number().meta({ description: "Items that existed at wipe time." })
+			}),
+			examples: [{
+				description: "A from-scratch reset.",
+				payload: {
+					deletedFiles: 24,
+					items: 24
+				}
+			}]
+		},
+		"events.iterate.com/media/processed": {
+			description: "One analysis settlement (the obligation's single terminal event): on success the processing fields overlay the item's, `error: null`; on terminal failure `error` says why and the item's previous fields stay. Also appended by legacy phone-driven re-analysis (no error/requestOffset).",
+			payloadSchema: object({
+				stableKey: string(),
+				...processingFields,
+				error: string().nullable().default(null).meta({ description: "Terminal analysis failure, or null on success." }),
+				requestOffset: number().nullable().default(null).meta({ description: "The uploaded/reanalyze event this settles (null on legacy appends)." })
+			}),
+			examples: [{
+				description: "A successful server-side analysis of an uploaded item.",
+				payload: {
+					stableKey: "abc123",
+					title: "Trenitalia ticket Rome→Florence 09:45",
+					markdown: "A train ticket from Rome to Florence.",
+					transcript: "Trenitalia 09:45",
+					tags: ["screenshot", "logistics"],
+					processedBy: "@cf/meta/llama-4-scout-17b-16e-instruct",
+					error: null,
+					requestOffset: 12
+				}
+			}]
+		}
+	},
+	consumes: [
+		"events.iterate.com/media/uploaded",
+		"events.iterate.com/media/reanalyze-requested",
+		"events.iterate.com/media/captured",
+		"events.iterate.com/media/processed",
+		"events.iterate.com/media/wiped"
+	],
+	emits: ["events.iterate.com/media/processed"]
+});
+var MediaProcessor = class extends StreamProcessor {
+	contract = MediaProcessorContract;
+	/**
+	* Runtime-only attempts by stableKey. The uploaded/reanalyze +
+	* processed events are the durable truth: after an eviction this set is
+	* empty and the next caught-up pass restarts any still-open obligation.
+	*/
+	#liveAnalyses = /* @__PURE__ */ new Set();
+	reduce({ event, state }) {
+		switch (event.type) {
+			case "events.iterate.com/media/uploaded":
+				if (state.items[event.payload.stableKey] !== void 0) return state;
+				return {
+					...state,
+					items: {
+						...state.items,
+						[event.payload.stableKey]: {
+							...event.payload,
+							capturedEventAt: event.createdAt,
+							title: "",
+							markdown: "",
+							transcript: "",
+							tags: [],
+							processedBy: "",
+							analysisError: null,
+							settledRequestOffset: null
+						}
+					},
+					pendingAnalyses: {
+						...state.pendingAnalyses,
+						[event.payload.stableKey]: pendingAnalysisFor(event)
+					}
+				};
+			case "events.iterate.com/media/reanalyze-requested": {
+				const item = state.items[event.payload.stableKey];
+				if (item === void 0) return state;
+				return {
+					...state,
+					pendingAnalyses: {
+						...state.pendingAnalyses,
+						[item.stableKey]: {
+							stableKey: item.stableKey,
+							path: item.path,
+							filename: item.filename,
+							contentType: item.contentType,
+							requestOffset: event.offset,
+							expiresAtMs: Date.parse(event.createdAt) + MEDIA_ANALYSIS_EXPIRY_MS
+						}
+					}
+				};
+			}
+			case "events.iterate.com/media/captured":
+				if (state.items[event.payload.stableKey] !== void 0) return state;
+				return {
+					...state,
+					items: {
+						...state.items,
+						[event.payload.stableKey]: {
+							...event.payload,
+							capturedEventAt: event.createdAt,
+							analysisError: null,
+							settledRequestOffset: null
+						}
+					}
+				};
+			case "events.iterate.com/media/wiped": return {
+				...state,
+				items: {},
+				pendingAnalyses: {}
+			};
+			case "events.iterate.com/media/processed": {
+				const pendingEntry = state.pendingAnalyses[event.payload.stableKey];
+				const existing = state.items[event.payload.stableKey];
+				const requestOffset = event.payload.requestOffset === void 0 ? null : event.payload.requestOffset;
+				const settledFloor = Math.max(pendingEntry === void 0 ? 0 : pendingEntry.requestOffset, existing?.settledRequestOffset || 0);
+				if (requestOffset !== null && requestOffset < settledFloor) return state;
+				const { [event.payload.stableKey]: _settled, ...pendingAnalyses } = state.pendingAnalyses;
+				if (existing === void 0) return {
+					...state,
+					pendingAnalyses
+				};
+				const error = event.payload.error || null;
+				const settledRequestOffset = requestOffset === null ? existing.settledRequestOffset : requestOffset;
+				const item = error === null ? {
+					...existing,
+					title: event.payload.title,
+					markdown: event.payload.markdown,
+					transcript: event.payload.transcript,
+					tags: event.payload.tags,
+					processedBy: event.payload.processedBy,
+					analysisError: null,
+					settledRequestOffset
+				} : {
+					...existing,
+					analysisError: error,
+					settledRequestOffset
+				};
+				return {
+					...state,
+					items: {
+						...state.items,
+						[event.payload.stableKey]: item
+					},
+					pendingAnalyses
+				};
+			}
+			default: return state;
+		}
+	}
+	processEvent(args) {
+		if (!args.delivery.caughtUp) return;
+		const now = this.deps.now();
+		const expired = [];
+		for (const pending of Object.values(args.state.pendingAnalyses)) {
+			if (this.#liveAnalyses.has(pending.stableKey)) continue;
+			if (now >= pending.expiresAtMs) {
+				expired.push(pending);
+				continue;
+			}
+			if (this.#liveAnalyses.size >= MAX_CONCURRENT_ANALYSES) continue;
+			this.#liveAnalyses.add(pending.stableKey);
+			args.runInBackground(async () => {
+				try {
+					const settlement = await this.#attemptAnalysis(pending);
+					await this.#appendSettlement(args.append, pending, settlement);
+				} finally {
+					this.#liveAnalyses.delete(pending.stableKey);
+				}
+			});
+		}
+		if (expired.length === 0) return;
+		args.blockProcessorWhile(async () => {
+			for (const pending of expired) await this.#appendSettlement(args.append, pending, { error: `analysis window expired before it could run (older than ${MEDIA_ANALYSIS_EXPIRY_MS / 36e5}h) — use Re-analyze to retry` });
+		});
+	}
+	/** One attempt = up to {@link ANALYSIS_TRIES} tries with short backoff. */
+	async #attemptAnalysis(pending) {
+		let lastError = "analysis failed";
+		for (let tryIndex = 0; tryIndex < ANALYSIS_TRIES; tryIndex++) {
+			if (tryIndex > 0) await this.deps.sleep(ANALYSIS_RETRY_BACKOFF_MS[Math.min(tryIndex - 1, ANALYSIS_RETRY_BACKOFF_MS.length - 1)]);
+			try {
+				return { result: await this.deps.analyze(pending) };
+			} catch (error) {
+				lastError = error instanceof Error ? error.message : String(error);
+			}
+		}
+		return { error: lastError.slice(0, 2e3) };
+	}
+	/**
+	* The obligation's single terminal event. The key is state-derived and
+	* deterministic per obligation (`@<stableKey>:<requestOffset>`); bodies
+	* contain AI output, so two racing incarnations can collide
+	* same-key/different-body — the first committed settlement is the
+	* authority and the loser tolerates the conflict (ai-linter shape).
+	*/
+	async #appendSettlement(append, pending, outcome) {
+		const event = {
+			type: "events.iterate.com/media/processed",
+			idempotencyKey: this.idempotencyKey(`analysis-settled@${pending.stableKey}:${pending.requestOffset}`),
+			payload: {
+				stableKey: pending.stableKey,
+				requestOffset: pending.requestOffset,
+				..."result" in outcome ? {
+					...outcome.result,
+					error: null
+				} : {
+					title: "",
+					markdown: "",
+					transcript: "",
+					tags: [],
+					processedBy: "",
+					error: outcome.error
+				}
+			}
+		};
+		try {
+			await append(event);
+		} catch (error) {
+			if (!isIdempotencyConflict(error)) throw error;
+		}
+	}
+};
+function pendingAnalysisFor(event) {
+	return {
+		stableKey: event.payload.stableKey,
+		path: event.payload.path,
+		filename: event.payload.filename,
+		contentType: event.payload.contentType,
+		requestOffset: event.offset,
+		expiresAtMs: Date.parse(event.createdAt) + MEDIA_ANALYSIS_EXPIRY_MS
+	};
+}
+/**
+* Search semantics shared with the phone's client-side filter
+* (apps/mobile/src/lib/media.ts filterMedia — kept in sync by hand, the two
+* runtimes can't share a module yet): every whitespace-separated term must
+* appear in description, transcript, filename, stored name, or tags; every
+* selected tag must be present. Newest first.
+*/
+function searchMediaItems(state, query) {
+	const terms = (query.q || "").toLowerCase().split(/\s+/).filter(Boolean);
+	const requiredTags = query.tags || [];
+	return Object.values(state.items).filter((item) => {
+		const storedName = (item.path.split("/").at(-1) || "").replace(/^[0-9a-f]{32,}-/, "");
+		const haystack = `${item.title} ${item.markdown} ${item.transcript} ${item.filename} ${storedName} ${item.tags.join(" ")}`.toLowerCase();
+		return terms.every((term) => haystack.includes(term)) && requiredTags.every((tag) => item.tags.includes(tag));
+	}).sort((a, b) => (b.capturedAt || b.capturedEventAt).localeCompare(a.capturedAt || a.capturedEventAt)).slice(0, query.limit || 20);
+}
+//#endregion
+//#region src/starter-apps/media/worker.ts
+var MediaApp = class extends StreamProcessorDurableObject {
+	streamPath = mediaStreamPath;
+	/** Analysis obligations must survive eviction: the keepalive revives this
+	* DO and the caught-up pass restarts still-open work from reduced state. */
+	recovery = true;
+	createProcessor(deps) {
+		return new MediaProcessor({
+			...deps,
+			now: Date.now,
+			sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+			analyze: async (input) => {
+				try {
+					var _usingCtx$1 = _usingCtx();
+					return await analyzeMediaImage(_usingCtx$1.u(await this.env.ITX.get()), input);
+				} catch (_) {
+					_usingCtx$1.e = _;
+				} finally {
+					_usingCtx$1.d();
+				}
+			}
+		});
+	}
+	/** Project-worker event delivery calls this after a durable /media event
+	* commits. Catch-up owns validation, ordering, checkpointing, and dedupe. */
+	async syncEvent(event) {
+		if (event.path !== "/media") return;
+		const registry = await this.registry();
+		await registry.catchUp("media");
+		registry.refreshLive();
+	}
+	/**
+	* Keyword search over descriptions, OCR transcripts, filenames, and tags —
+	* "train ticket" finds the train ticket because the vision model's prose
+	* says so. `tags` all must be present; newest first; default limit 20.
+	*/
+	async search(query) {
+		try {
+			var _usingCtx3 = _usingCtx();
+			await (await this.registry()).catchUp("media");
+			const { state } = await this.snapshot();
+			const hits = searchMediaItems(state, query);
+			const project = _usingCtx3.u(await this.env.ITX.get());
+			return await Promise.all(hits.map(async (item) => ({
+				...item,
+				url: await project.files.get(item.path).url()
+			})));
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	}
+	/** Newest items, no filtering — `search` with an empty query. */
+	async list(query) {
+		return this.search({ limit: query.limit });
+	}
+	/** One item by its content hash, or null. */
+	async get(stableKey) {
+		await (await this.registry()).catchUp("media");
+		const { state } = await this.snapshot();
+		return state.items[stableKey] || null;
+	}
+};
+//#endregion
+export { MediaApp };
+
+//# sourceMappingURL=configured-worker.mjs.map