@ai-matrx/agents 0.17.4 → 0.18.1

package/dist/sources/runtime/index.cjs

@@ -0,0 +1,1354 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// sources/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  DELIVERY_CHOICES: () => DELIVERY_CHOICES,
+  DELIVERY_WORDS: () => DELIVERY_WORDS,
+  EMPTY_SOURCE_SET_STATE: () => EMPTY_SOURCE_SET_STATE,
+  HEAVY_SHARE: () => HEAVY_SHARE,
+  KEEP_WAITING_FOR_ORGANIZATION: () => KEEP_WAITING_FOR_ORGANIZATION,
+  MAX_KEPT_TEXT_KNOB: () => MAX_KEPT_TEXT_KNOB,
+  NOT_KEPT_FOR_RELOAD: () => NOT_KEPT_FOR_RELOAD,
+  RELOADED_RESUMING: () => RELOADED_RESUMING,
+  RELOADED_WHILE_ADDING: () => RELOADED_WHILE_ADDING,
+  SAME_SOURCE_AGAIN: () => SAME_SOURCE_AGAIN,
+  SOURCE_CHARS_PER_TOKEN: () => SOURCE_CHARS_PER_TOKEN,
+  SourceDoorError: () => SourceDoorError,
+  WAITING_FOR_ORGANIZATION: () => WAITING_FOR_ORGANIZATION,
+  addPendingCard: () => addPendingCard,
+  addReadyCard: () => addReadyCard,
+  allowedDeliveries: () => allowedDeliveries,
+  applyManifest: () => applyManifest,
+  applyReviewedSourceSet: () => applyReviewedSourceSet,
+  cardsToResume: () => cardsToResume,
+  cardsWaitingForOrganization: () => cardsWaitingForOrganization,
+  chosenForm: () => chosenForm,
+  continueAfterOrganization: () => continueAfterOrganization,
+  createFetchSourcesTransport: () => createFetchSourcesTransport,
+  createMemorySourceDraftStorage: () => createMemorySourceDraftStorage,
+  createMemorySourceSetStore: () => createMemorySourceSetStore,
+  createSourceIntake: () => createSourceIntake,
+  createSourceSetController: () => createSourceSetController,
+  createSourcesClient: () => createSourcesClient,
+  deliveryChoicesFor: () => deliveryChoicesFor,
+  deliveryPatch: () => deliveryPatch,
+  deliverySwitchedNote: () => deliverySwitchedNote,
+  draftKindForToken: () => draftKindForToken,
+  estimateSourceTokens: () => estimateSourceTokens,
+  failCard: () => failCard,
+  fileCardHeldForOrganization: () => fileCardHeldForOrganization,
+  fileSourcePollDelayMs: () => fileSourcePollDelayMs,
+  findParts: () => findParts,
+  fitCardDeliveries: () => fitCardDeliveries,
+  fitDelivery: () => fitDelivery,
+  hasSourceRef: () => hasSourceRef,
+  isAskableFileCard: () => isAskableFileCard,
+  isSourceDraft: () => isSourceDraft,
+  isWaitingFileCard: () => isWaitingFileCard,
+  isWordQuery: () => isWordQuery,
+  lookAtFileCards: () => lookAtFileCards,
+  matchesPart: () => matchesPart,
+  nextFileStep: () => nextFileStep,
+  partPages: () => partPages,
+  planSourceReview: () => planSourceReview,
+  readPersistedSourceInput: () => readPersistedSourceInput,
+  readySourceRefs: () => readySourceRefs,
+  registeredFileEdge: () => registeredFileEdge,
+  reloadedCard: () => reloadedCard,
+  removeCard: () => removeCard,
+  renderedPartChars: () => renderedPartChars,
+  restartCard: () => restartCard,
+  restoredCards: () => restoredCards,
+  resumableInput: () => resumableInput,
+  resumeInterrupted: () => resumeInterrupted,
+  sameSourceRef: () => sameSourceRef,
+  selectSettled: () => selectSettled,
+  selectSourceSet: () => selectSourceSet,
+  selectTotalChars: () => selectTotalChars,
+  setCardWaitForClean: () => setCardWaitForClean,
+  setSourceTopic: () => setSourceTopic,
+  settleCard: () => settleCard,
+  sourceAttachTargets: () => sourceAttachTargets,
+  sourceDelivery: () => sourceDelivery,
+  sourceKey: () => sourceKey,
+  sourceRecoveryGuards: () => sourceRecoveryGuards,
+  sourceRoomLeft: () => sourceRoomLeft,
+  toPersistedSourceInput: () => toPersistedSourceInput,
+  updateCardDraft: () => updateCardDraft,
+  updateCardRef: () => updateCardRef,
+  uploadCutOffSentence: () => uploadCutOffSentence,
+  withDefaultForm: () => withDefaultForm,
+  withDisplayNames: () => withDisplayNames
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// sources/runtime/delivery.ts
+function sourceDelivery(ref) {
+  return ref?.delivery === "context" ? "context" : "direct";
+}
+function deliveryPatch(delivery) {
+  return delivery === "context" ? { delivery: "context", include_segments: void 0, max_chars: void 0 } : { delivery: void 0 };
+}
+var DELIVERY_WORDS = {
+  direct: {
+    label: "Include the text",
+    hint: "The text is handed to the AI with your request, so it reads all of it before it starts.",
+    summary: "Text included"
+  },
+  context: {
+    label: "Let the AI look it up",
+    hint: "Nothing is sent up front. The AI opens this Source and reads the parts it needs while it works \u2014 best for very large Sources.",
+    summary: "Looked up when needed"
+  }
+};
+var DELIVERY_CHOICES = ["direct", "context"].map((value) => ({ value, ...DELIVERY_WORDS[value] }));
+function allowedDeliveries(deliveries) {
+  const allowed = ["direct", "context"].filter((d) => !deliveries || deliveries.includes(d));
+  return allowed.length > 0 ? allowed : ["direct"];
+}
+function deliveryChoicesFor(deliveries) {
+  const allowed = allowedDeliveries(deliveries);
+  return DELIVERY_CHOICES.filter((c) => allowed.includes(c.value));
+}
+function deliverySwitchedNote(to) {
+  return to === "direct" ? `This Source was set to "${DELIVERY_WORDS.context.label}", which this page cannot use \u2014 it needs the text up front \u2014 so it was switched back to "${DELIVERY_WORDS.direct.label}".` : `This Source was set to "${DELIVERY_WORDS.direct.label}", which this page cannot use, so it was switched to "${DELIVERY_WORDS.context.label}".`;
+}
+function fitDelivery(ref, deliveries) {
+  if (!ref) return null;
+  const allowed = allowedDeliveries(deliveries);
+  const current = sourceDelivery(ref);
+  if (allowed.includes(current)) return null;
+  const to = allowed[0];
+  return { patch: deliveryPatch(to), to };
+}
+
+// sources/runtime/partsSearch.ts
+var RANGE_RE = /^(\d+)\s*(?:-|–|—|to)\s*(\d+)$/;
+var SPAN_RE = /(\d+)\s*[–—-]\s*(\d+)/;
+function partPages(part) {
+  if (part.page === void 0 || part.page === null) return null;
+  const span = /^pages?\s/i.test(part.label) ? SPAN_RE.exec(part.label) : null;
+  if (span) return [Number(span[1]), Number(span[2])];
+  return [part.page, part.page];
+}
+function isWordQuery(query) {
+  const q = query.trim().toLowerCase();
+  return q.length > 0 && !/^\d+$/.test(q) && !RANGE_RE.test(q);
+}
+function normalise(text) {
+  return text.toLowerCase().replace(/\s+/g, " ");
+}
+function matchesPart(part, query, serverMatches) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const pages = partPages(part);
+  const range = RANGE_RE.exec(q);
+  if (range && pages) {
+    const from = Math.min(Number(range[1]), Number(range[2]));
+    const to = Math.max(Number(range[1]), Number(range[2]));
+    return pages[0] <= to && pages[1] >= from;
+  }
+  if (/^\d+$/.test(q) && pages) {
+    const n = Number(q);
+    return pages[0] <= n && n <= pages[1];
+  }
+  if (part.id.toLowerCase() === q) return true;
+  if (serverMatches?.has(part.id)) return true;
+  const haystack = normalise([part.label, part.preview ?? ""].join(" "));
+  return q.split(/\s+/).filter(Boolean).every((word) => haystack.includes(word));
+}
+function findParts(parts, query, serverMatches) {
+  return parts.filter((p) => matchesPart(p, query, serverMatches));
+}
+
+// sources/runtime/interrupted.ts
+var RELOADED_RESUMING = "The page reloaded while this was being added \u2014 picking it up again.";
+var RELOADED_WHILE_ADDING = "This was still being added when the page reloaded, so it did not finish. Add it again.";
+function resumableInput(draft) {
+  const input = draft.input;
+  if (!input) return null;
+  switch (draft.kind) {
+    case "paste":
+      return input.text?.trim() ? input : null;
+    case "web":
+    case "youtube":
+      return input.url?.trim() ? input : null;
+    case "audio":
+      return input.fileId ? input : null;
+    default:
+      return null;
+  }
+}
+function uploadCutOffSentence(draft) {
+  return `"${draft.label}" was still uploading when the page reloaded, so it did not arrive. Choose it again to add it.`;
+}
+function reloadedCard(draft, status) {
+  if (status !== "pending" && status !== "resolving") return null;
+  if (resumableInput(draft)) return { action: "resume", sentence: RELOADED_RESUMING };
+  if (draft.kind === "upload" || draft.kind === "image" || draft.kind === "audio")
+    return { action: "reoffer", sentence: uploadCutOffSentence(draft) };
+  return { action: "lost", sentence: RELOADED_WHILE_ADDING };
+}
+var MAX_KEPT_TEXT_KNOB = { feature: "sources", key: "max_kept_draft_chars" };
+var NOT_KEPT_FOR_RELOAD = "Too large to keep on this device, so it will not come back if the page reloads before it is added.";
+var WAITING_FOR_ORGANIZATION = "Waiting for an organization \u2014 choose one and this continues by itself.";
+var KEEP_WAITING_FOR_ORGANIZATION = "Read. Waiting for an organization to keep it \u2014 choose one and it is kept by itself.";
+
+// sources/runtime/fileSource.ts
+var UNREADABLE = "The file is stored, but it could not be read into a Source, so nothing in it can be used yet. Remove it, or add a different copy (a PDF, Word file or plain text reads best).";
+function nextFileStep(status, ctx) {
+  const pdId = status?.processed_document_id ?? null;
+  if (pdId) return { do: "keep", processedDocumentId: pdId };
+  if (ctx.localRunning || status?.state === "running") return { do: "wait" };
+  if (status?.state === "failed")
+    return {
+      do: "unreadable",
+      reason: status.error?.message ? `The file could not be read: ${status.error.message}. Remove it, or add it again.` : UNREADABLE
+    };
+  if (!ctx.started) return { do: "start" };
+  return { do: "unreadable", reason: UNREADABLE };
+}
+function fileSourcePollDelayMs(round) {
+  if (round < 5) return 3e3;
+  if (round < 20) return 6e3;
+  return 15e3;
+}
+function isWaitingFileCard(card) {
+  return card.status === "ready" && card.draft.ref?.resource_type === "file" && !!card.draft.fileId && !card.draft.processedDocumentId;
+}
+function fileCardHeldForOrganization(card, activeOrganizationId, fileOrganizationId) {
+  if (!isWaitingFileCard(card)) return false;
+  if (activeOrganizationId) return false;
+  return !fileOrganizationId?.(card.draft.fileId);
+}
+
+// sources/runtime/tokens.ts
+var SOURCE_CHARS_PER_TOKEN = {
+  prose: 2.9,
+  structured: 2.4
+};
+function estimateSourceTokens(chars) {
+  if (!Number.isFinite(chars) || chars <= 0) return 0;
+  return Math.ceil(chars / SOURCE_CHARS_PER_TOKEN.prose);
+}
+
+// sources/index.ts
+var RESOURCE_REF_KIND = "resource_ref";
+var SOURCE_SET_KIND = "source_set";
+var RESOLVED_SOURCE_SET_KIND = "resolved_source_set";
+var SOURCE_SET_VERSION = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createSourceRef(resourceType, resourceId, options = {}) {
+  const resource_type = resourceType.trim();
+  const resource_id = resourceId.trim();
+  if (!resource_type) throw new Error("createSourceRef: resource_type is required");
+  if (!resource_id) throw new Error("createSourceRef: resource_id is required");
+  if (options.max_chars !== void 0 && (!Number.isInteger(options.max_chars) || options.max_chars <= 0)) {
+    throw new Error("createSourceRef: max_chars must be a positive integer");
+  }
+  const exclude = Array.from(
+    new Set(
+      (options.exclude ?? []).map((value) => value.trim().toLowerCase()).filter(Boolean)
+    )
+  );
+  const include_segments = Array.from(
+    new Set((options.include_segments ?? []).map((id) => id.trim()).filter(Boolean))
+  );
+  return {
+    __kind: RESOURCE_REF_KIND,
+    resource_type,
+    resource_id,
+    ...options.representation ? { representation: options.representation } : {},
+    ...include_segments.length ? { include_segments } : {},
+    ...options.delivery ? { delivery: options.delivery } : {},
+    ...options.max_chars !== void 0 ? { max_chars: options.max_chars } : {},
+    ...options.promote ? { promote: options.promote } : {},
+    ...exclude.length ? { exclude } : {}
+  };
+}
+function isSourceRef(value) {
+  return isRecord(value) && value.__kind === RESOURCE_REF_KIND && typeof value.resource_type === "string" && value.resource_type.length > 0 && typeof value.resource_id === "string" && value.resource_id.length > 0;
+}
+function createSourceSet(sources, options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const ref of sources) {
+    if (!isSourceRef(ref)) throw new Error("createSourceSet: every source must be a resource_ref");
+    const key = `${ref.resource_type}\0${ref.resource_id}\0${ref.representation ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(ref);
+  }
+  const topic = options.topic?.trim();
+  const retrieve_query = options.retrieve_query?.trim();
+  if (options.grounding === "retrieve" && !retrieve_query) {
+    throw new Error('createSourceSet: grounding "retrieve" needs a retrieve_query');
+  }
+  if (options.grounding === "selected" && !unique.some((ref) => (ref.include_segments?.length ?? 0) > 0)) {
+    throw new Error('createSourceSet: grounding "selected" needs at least one Source with include_segments');
+  }
+  return {
+    __kind: SOURCE_SET_KIND,
+    version: SOURCE_SET_VERSION,
+    sources: unique,
+    ...topic ? { topic } : {},
+    ...options.grounding ? { grounding: options.grounding } : {},
+    ...retrieve_query ? { retrieve_query } : {},
+    ...options.target_model_id ? { target_model_id: options.target_model_id } : {}
+  };
+}
+function manifestEntryChars(entry) {
+  const selected = entry.ref.include_segments;
+  let chars;
+  if (selected?.length && entry.segments?.length) {
+    const wanted = new Set(selected);
+    chars = entry.segments.filter((segment) => wanted.has(segment.id)).reduce((sum, segment) => sum + segment.chars, 0);
+  } else {
+    const formKey = entry.ref.representation ?? entry.default_form;
+    const form = entry.forms.find((candidate) => candidate.form === formKey) ?? entry.forms.find((candidate) => candidate.form === entry.default_form);
+    chars = form?.chars ?? 0;
+  }
+  return entry.ref.max_chars !== void 0 ? Math.min(chars, entry.ref.max_chars) : chars;
+}
+function totalChars(value) {
+  if (value.__kind === RESOLVED_SOURCE_SET_KIND) {
+    return value.sources.reduce((sum, source) => sum + source.text.length, 0);
+  }
+  return value.sources.filter((entry) => entry.state === "ready" || entry.state === "processing").reduce((sum, entry) => sum + manifestEntryChars(entry), 0);
+}
+
+// sources/runtime/plan.ts
+var HEAVY_SHARE = 0.7;
+var PAGE_SUFFIX = (page) => page !== void 0 && page > 0 ? ` (page ${page})` : "";
+function renderedPartChars(segment, chars) {
+  return `### Chunk ${segment.id}${PAGE_SUFFIX(segment.page)}`.length + 1 + chars;
+}
+function capParts(parts, maxChars) {
+  if (!maxChars) return { kept: parts.map((seg) => ({ seg, chars: seg.chars })), capped: false };
+  const kept = [];
+  let used = 0;
+  for (const seg of parts) {
+    if (used + seg.chars <= maxChars) {
+      kept.push({ seg, chars: seg.chars });
+      used += seg.chars;
+      continue;
+    }
+    const room = maxChars - used;
+    if (room > 0 && kept.length === 0) kept.push({ seg, chars: room });
+    return { kept, capped: true };
+  }
+  return { kept, capped: false };
+}
+function chosenForm(entry, ref) {
+  const key = ref.representation ?? entry.default_form;
+  return entry.forms.find((f) => f.form === key) ?? entry.forms.find((f) => f.form === entry.default_form) ?? null;
+}
+function isUsable(entry) {
+  return entry.state === "ready" || entry.state === "processing";
+}
+function measure(entry, ref) {
+  const form = chosenForm(entry, ref);
+  const formChars = form?.chars ?? 0;
+  const formLabel = form?.label ?? "Text";
+  const segments = entry.segments ?? null;
+  if (segments && segments.length > 0) {
+    const wanted = ref.include_segments?.length ? new Set(ref.include_segments) : null;
+    const chosen = wanted ? segments.filter((s) => wanted.has(s.id)) : segments;
+    const { kept, capped: capped2 } = capParts(chosen, ref.max_chars);
+    const body = kept.reduce((sum, k) => sum + renderedPartChars(k.seg, k.chars), 0);
+    const sentChars = kept.length ? body + 2 * (kept.length - 1) : 0;
+    return {
+      formChars,
+      formLabel,
+      sentChars,
+      exact: true,
+      partsSent: kept.length,
+      partsTotal: segments.length,
+      capped: capped2
+    };
+  }
+  const capped = ref.max_chars !== void 0 && formChars > ref.max_chars;
+  return {
+    formChars,
+    formLabel,
+    sentChars: capped ? ref.max_chars ?? formChars : formChars,
+    exact: false,
+    partsSent: null,
+    partsTotal: null,
+    capped
+  };
+}
+function planSourceReview(input) {
+  const estimateTokens = input.estimateTokens ?? estimateSourceTokens;
+  const windowIsFallback = !input.modelWindowTokens || input.modelWindowTokens <= 0;
+  const windowTokens = windowIsFallback ? input.fallbackWindowTokens : input.modelWindowTokens;
+  let sentChars = 0;
+  const entries = input.manifest.sources.map((entry, index) => {
+    const ref = input.refs[index] ?? entry.ref;
+    const m = measure(entry, ref);
+    const base = { index, ref, entry, ...m };
+    if (!isUsable(entry)) {
+      return { ...base, status: "unusable", sentChars: 0, sentTokens: 0 };
+    }
+    if (sourceDelivery(ref) === "context") {
+      return { ...base, status: "on_demand", sentChars: 0, sentTokens: 0 };
+    }
+    if (estimateTokens(sentChars + m.sentChars) > windowTokens) {
+      return { ...base, status: "left_out", sentTokens: estimateTokens(m.sentChars) };
+    }
+    sentChars += m.sentChars;
+    return { ...base, status: "included", sentTokens: estimateTokens(m.sentChars) };
+  });
+  const sentTokens = estimateTokens(sentChars);
+  const leftOut = entries.filter((e) => e.status === "left_out");
+  const share = windowTokens > 0 ? sentTokens / windowTokens : 0;
+  const anythingGoesIn = entries.some((e) => e.status === "included" || e.status === "on_demand");
+  const verdict = !anythingGoesIn && leftOut.length === 0 ? "empty" : leftOut.length > 0 ? "too_much" : share >= HEAVY_SHARE ? "heavy" : "fine";
+  const kept = entries.filter((e) => e.status !== "left_out").map(
+    (e) => createSourceRef(e.ref.resource_type, e.ref.resource_id, {
+      representation: e.ref.representation,
+      include_segments: e.ref.include_segments,
+      delivery: e.ref.delivery,
+      max_chars: e.ref.max_chars,
+      promote: e.ref.promote,
+      exclude: e.ref.exclude
+    })
+  );
+  const grounding = input.base.grounding === "selected" && !kept.some((r) => r.include_segments?.length) ? void 0 : input.base.grounding;
+  const sourceSet = createSourceSet(kept, {
+    topic: input.base.topic,
+    grounding,
+    retrieve_query: input.base.retrieve_query,
+    target_model_id: input.targetModelId ?? input.base.target_model_id
+  });
+  return {
+    entries,
+    sentChars,
+    sentTokens,
+    windowTokens,
+    windowIsFallback,
+    verdict,
+    share,
+    leftOut,
+    sourceSet
+  };
+}
+
+// sources/runtime/client.ts
+function marked(options) {
+  return {
+    bodyCarriedRead: true,
+    ...options?.organizationId ? { organizationId: options.organizationId } : {},
+    ...options?.signal ? { signal: options.signal } : {}
+  };
+}
+function createSourcesClient(transport) {
+  return {
+    manifest: (sourceSet, options) => transport.post("/sources/manifest", { source_set: sourceSet }, marked(options)),
+    resolve: (sourceSet, options) => transport.post("/sources/resolve", { source_set: sourceSet }, marked(options)),
+    searchParts: (ref, query, options) => transport.post("/sources/parts/search", { source_ref: ref, query }, marked(options))
+  };
+}
+var SourceDoorError = class extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.name = "SourceDoorError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function refusalMessage(status, body) {
+  if (body && typeof body === "object") {
+    const record = body;
+    const error = record.error;
+    if (error && typeof error === "object") {
+      const message = error.user_message ?? error.message;
+      if (typeof message === "string" && message) return message;
+    }
+    if (typeof record.detail === "string" && record.detail) return record.detail;
+  }
+  return `The server answered ${status}.`;
+}
+function createFetchSourcesTransport(options) {
+  const base = options.baseUrl.replace(/\/+$/, "");
+  return {
+    async post(path, body, call) {
+      const doFetch = options.fetch ?? fetch;
+      const headers = {
+        "Content-Type": "application/json",
+        ...options.headers ? await options.headers() : {}
+      };
+      if (call.organizationId) headers[options.organizationHeader ?? "X-Organization-Id"] = call.organizationId;
+      const response = await doFetch(`${base}${path}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        ...call.signal ? { signal: call.signal } : {}
+      });
+      const text = await response.text();
+      let parsed = null;
+      try {
+        parsed = text ? JSON.parse(text) : null;
+      } catch {
+        parsed = text;
+      }
+      if (!response.ok) throw new SourceDoorError(response.status, refusalMessage(response.status, parsed), parsed);
+      return parsed;
+    }
+  };
+}
+
+// sources/runtime/state.ts
+var EMPTY_SOURCE_SET_STATE = Object.freeze({ cards: Object.freeze([]), topic: "" });
+var SAME_SOURCE_AGAIN = "You added this again \u2014 it is the same Source, so it is listed once.";
+function isSourceDraft(value) {
+  return !!value && typeof value === "object" && typeof value.kind === "string" && typeof value.label === "string";
+}
+function sameSourceRef(a, b) {
+  return a.resource_type === b.resource_type && a.resource_id === b.resource_id;
+}
+function sourceKey(ref) {
+  return `${ref.resource_type}:${ref.resource_id}`;
+}
+function draftKindForToken(token) {
+  if (token === "file") return "files";
+  if (token === "note") return "notes";
+  if (token === "processed_document") return "your_sources";
+  return "records";
+}
+function withDefaultForm(ref, defaultForm) {
+  return defaultForm && !ref.representation ? createSourceRef(ref.resource_type, ref.resource_id, { ...ref, representation: defaultForm }) : ref;
+}
+function cardById(state, id) {
+  return state.cards.find((c) => c.id === id);
+}
+function replaceCard(state, id, patch) {
+  let changed = false;
+  const cards = state.cards.map((c) => {
+    if (c.id !== id) return c;
+    const next = patch(c);
+    if (next !== c) changed = true;
+    return next;
+  });
+  return changed ? { ...state, cards } : state;
+}
+function addReadyCard(state, id, draft, options = {}) {
+  const ref = draft.ref ? withDefaultForm(draft.ref, options.defaultForm) : null;
+  return {
+    ...state,
+    cards: [...state.cards, { id, draft: { ...draft, ref }, status: "ready", error: null, manifest: null }]
+  };
+}
+function addPendingCard(state, id, draft) {
+  return {
+    ...state,
+    cards: [...state.cards, { id, draft: { ...draft, ref: null }, status: "resolving", error: null, manifest: null }]
+  };
+}
+function settleCard(state, id, patch, options = {}) {
+  const card = cardById(state, id);
+  if (!card) return state;
+  const twin = state.cards.find((c) => c.id !== id && c.draft.ref && sameSourceRef(c.draft.ref, patch.ref));
+  if (twin) {
+    const without = { ...state, cards: state.cards.filter((c) => c.id !== id) };
+    if (twin.draft.notes?.includes(SAME_SOURCE_AGAIN)) return without;
+    return replaceCard(without, twin.id, (c) => ({
+      ...c,
+      draft: { ...c.draft, notes: [...c.draft.notes ?? [], SAME_SOURCE_AGAIN] }
+    }));
+  }
+  return replaceCard(state, id, (c) => ({
+    ...c,
+    // Landed: the kept input has done its job and leaves the draft.
+    draft: { ...c.draft, ...patch, input: void 0, ref: withDefaultForm(patch.ref, options.defaultForm) },
+    status: "ready",
+    error: null
+  }));
+}
+function failCard(state, id, sentence) {
+  return replaceCard(state, id, (c) => ({ ...c, status: "error", error: sentence }));
+}
+function restartCard(state, id) {
+  return replaceCard(state, id, (c) => ({ ...c, status: "resolving", error: null }));
+}
+function updateCardDraft(state, id, patch) {
+  return replaceCard(state, id, (c) => ({ ...c, draft: { ...c.draft, ...patch } }));
+}
+function removeCard(state, id) {
+  if (!cardById(state, id)) return state;
+  return { ...state, cards: state.cards.filter((c) => c.id !== id) };
+}
+function updateCardRef(state, id, options) {
+  return replaceCard(state, id, (c) => {
+    if (!c.draft.ref) return c;
+    const ref = createSourceRef(c.draft.ref.resource_type, c.draft.ref.resource_id, { ...c.draft.ref, ...options });
+    return { ...c, draft: { ...c.draft, ref } };
+  });
+}
+function setCardWaitForClean(state, id, wait) {
+  return replaceCard(state, id, (c) => ({ ...c, draft: { ...c.draft, waitForClean: wait } }));
+}
+function setSourceTopic(state, topic) {
+  return state.topic === topic ? state : { ...state, topic };
+}
+function applyReviewedSourceSet(state, set) {
+  let next = state;
+  for (const card of state.cards) {
+    const ref = card.draft.ref;
+    if (!ref) continue;
+    const match = set.sources.find((r) => sameSourceRef(r, ref));
+    if (!match) continue;
+    next = replaceCard(next, card.id, (c) => ({ ...c, draft: { ...c.draft, ref: match } }));
+  }
+  return set.topic !== void 0 ? setSourceTopic(next, set.topic) : next;
+}
+function applyManifest(state, manifest) {
+  let next = state;
+  for (const card of state.cards) {
+    const ref = card.draft.ref;
+    if (!ref || card.status !== "ready") continue;
+    const entry = manifest.sources.find((e) => sameSourceRef(e.ref, ref));
+    if (entry) next = replaceCard(next, card.id, (c) => ({ ...c, manifest: entry }));
+  }
+  return next;
+}
+function fitCardDeliveries(state, deliveries) {
+  let next = state;
+  for (const card of state.cards) {
+    const fit = fitDelivery(card.draft.ref, deliveries);
+    if (!fit) continue;
+    next = updateCardRef(next, card.id, fit.patch);
+    const note = deliverySwitchedNote(fit.to);
+    if (!card.draft.notes?.includes(note))
+      next = updateCardDraft(next, card.id, { notes: [...card.draft.notes ?? [], note] });
+  }
+  return next;
+}
+function readPersistedSourceInput(data) {
+  const record = data && typeof data === "object" ? data : void 0;
+  const sources = Array.isArray(record?.sources) ? record.sources.filter(
+    (c) => !!c && typeof c.id === "string" && isSourceDraft(c.draft)
+  ) : [];
+  return { sources, topic: typeof record?.topic === "string" ? record.topic : "" };
+}
+function toPersistedSourceInput(state) {
+  return {
+    sources: state.cards.map((c) => ({ id: c.id, draft: c.draft, status: c.status, error: c.error })),
+    topic: state.topic
+  };
+}
+function restoredCards(persisted) {
+  return persisted.sources.map((card) => {
+    const reloaded = reloadedCard(
+      card.draft,
+      card.status === "error" && card.error === WAITING_FOR_ORGANIZATION ? "resolving" : card.status
+    );
+    return {
+      id: card.id,
+      draft: card.draft,
+      status: reloaded ? "error" : card.status,
+      error: reloaded ? reloaded.sentence : card.error ?? null,
+      manifest: null
+    };
+  });
+}
+function readySourceRefs(state) {
+  return state.cards.flatMap((c) => c.status === "ready" && c.draft.ref ? [c.draft.ref] : []);
+}
+function hasSourceRef(state, resourceType, resourceId) {
+  return state.cards.some(
+    (c) => c.draft.ref?.resource_type === resourceType && c.draft.ref.resource_id === resourceId
+  );
+}
+function selectSourceSet(state, options = {}) {
+  const topic = state.topic.trim();
+  return createSourceSet(readySourceRefs(state), {
+    topic: topic || void 0,
+    grounding: "whole",
+    target_model_id: options.targetModelId
+  });
+}
+function selectTotalChars(state) {
+  const measured = state.cards.flatMap(
+    (c) => c.status === "ready" && c.manifest && c.draft.ref ? [{ ...c.manifest, ref: c.draft.ref }] : []
+  );
+  if (!measured.length) return 0;
+  return totalChars({
+    __kind: "source_manifest",
+    sources: measured,
+    total_chars: 0,
+    estimated_tokens: 0,
+    model_context_tokens: null
+  });
+}
+function selectSettled(state) {
+  return state.cards.every((c) => c.status === "ready");
+}
+function sourceRoomLeft(state, max) {
+  return max === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, max - state.cards.length);
+}
+function withDisplayNames(resolved, cards) {
+  const names = /* @__PURE__ */ new Map();
+  for (const c of cards) {
+    const label = c.draft.label?.trim();
+    if (c.draft.ref && label) names.set(sourceKey(c.draft.ref), label);
+  }
+  return {
+    ...resolved,
+    sources: resolved.sources.map((s) => {
+      const name = names.get(sourceKey(s.ref));
+      return name ? { ...s, label: name } : s;
+    })
+  };
+}
+
+// sources/runtime/controller.ts
+function randomId() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.randomUUID) return cryptoApi.randomUUID();
+  return `src-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createMemorySourceSetStore(initial = EMPTY_SOURCE_SET_STATE) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getState: () => state,
+    setState(next) {
+      if (next === state) return;
+      state = next;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function createMemorySourceDraftStorage(initial = void 0) {
+  let saved = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    load: () => saved,
+    save(value) {
+      saved = value;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    current: () => saved
+  };
+}
+function createSourceSetController(adapter) {
+  const { store, persistence } = adapter;
+  let config = { ...adapter.config ?? {} };
+  const createId = adapter.createId ?? randomId;
+  const describe = adapter.describeError ?? errorText;
+  let meta = { measuring: false, manifestError: null };
+  const metaListeners = /* @__PURE__ */ new Set();
+  let hydrated = false;
+  let measurement = null;
+  const setMeta = (patch) => {
+    const next = { ...meta, ...patch };
+    if (next.measuring === meta.measuring && next.manifestError === meta.manifestError) return;
+    meta = next;
+    for (const listener of [...metaListeners]) listener();
+  };
+  const commit = (next) => {
+    hydrated = true;
+    if (next !== store.getState()) store.setState(next);
+    persistence?.save(toPersistedSourceInput(store.getState()));
+  };
+  const has = (id) => store.getState().cards.some((c) => c.id === id);
+  const controller = {
+    getState: () => store.getState(),
+    subscribe: (listener) => store.subscribe(listener),
+    getMeta: () => meta,
+    subscribeMeta(listener) {
+      metaListeners.add(listener);
+      return () => metaListeners.delete(listener);
+    },
+    configure(next) {
+      config = { ...next };
+    },
+    get config() {
+      return config;
+    },
+    restore(saved) {
+      if (hydrated) return false;
+      const live = store.getState();
+      if (live.cards.length > 0) {
+        hydrated = true;
+        return false;
+      }
+      const persisted = readPersistedSourceInput(saved);
+      if (persisted.sources.length === 0) return false;
+      hydrated = true;
+      store.setState({ cards: restoredCards(persisted), topic: live.topic || persisted.topic });
+      return true;
+    },
+    addReady(draft) {
+      const id = createId();
+      commit(addReadyCard(store.getState(), id, draft, { defaultForm: config.defaultForm }));
+      return id;
+    },
+    addPending(draft) {
+      const id = createId();
+      commit(addPendingCard(store.getState(), id, draft));
+      return id;
+    },
+    settle(id, patch) {
+      if (!has(id)) return;
+      commit(settleCard(store.getState(), id, patch, { defaultForm: config.defaultForm }));
+    },
+    fail(id, sentence) {
+      if (!has(id)) return;
+      commit(failCard(store.getState(), id, sentence));
+    },
+    restart(id) {
+      if (!has(id)) return false;
+      commit(restartCard(store.getState(), id));
+      return true;
+    },
+    updateDraft(id, patch) {
+      if (!has(id)) return;
+      commit(updateCardDraft(store.getState(), id, patch));
+    },
+    remove(id) {
+      commit(removeCard(store.getState(), id));
+    },
+    updateRef(id, options) {
+      if (!store.getState().cards.find((c) => c.id === id)?.draft.ref) return;
+      commit(updateCardRef(store.getState(), id, options));
+    },
+    setWaitForClean(id, wait) {
+      if (!has(id)) return;
+      commit(setCardWaitForClean(store.getState(), id, wait));
+    },
+    setTopic(topic) {
+      commit(setSourceTopic(store.getState(), topic));
+    },
+    hasRef: (resourceType, resourceId) => hasSourceRef(store.getState(), resourceType, resourceId),
+    liveCount: () => store.getState().cards.length,
+    toSourceSet: (options = {}) => selectSourceSet(store.getState(), options),
+    applySourceSet(set) {
+      commit(applyReviewedSourceSet(store.getState(), set));
+    },
+    async manifest() {
+      const refs = readySourceRefs(store.getState());
+      if (refs.length === 0) {
+        setMeta({ manifestError: null });
+        return null;
+      }
+      if (!adapter.client) throw new Error("createSourceSetController: manifest() needs a client in the adapter");
+      measurement?.abort();
+      const controllerForThis = new AbortController();
+      measurement = controllerForThis;
+      setMeta({ measuring: true });
+      try {
+        const result = await adapter.client.manifest(createSourceSet(refs), {
+          organizationId: config.organizationId ?? void 0,
+          signal: controllerForThis.signal
+        });
+        if (measurement !== controllerForThis) return null;
+        const next = applyManifest(store.getState(), result);
+        if (next !== store.getState()) store.setState(next);
+        setMeta({ manifestError: null });
+        return result;
+      } catch (err) {
+        if (measurement !== controllerForThis) return null;
+        setMeta({
+          manifestError: `Sizes and parts could not be read: ${describe(err)} Your picks are kept \u2014 try again.`
+        });
+        return null;
+      } finally {
+        if (measurement === controllerForThis) setMeta({ measuring: false });
+      }
+    },
+    async resolve(options = {}) {
+      if (!adapter.client) throw new Error("createSourceSetController: resolve() needs a client in the adapter");
+      const resolved = await adapter.client.resolve(controller.toSourceSet(options), {
+        organizationId: config.organizationId ?? void 0
+      });
+      return withDisplayNames(resolved, store.getState().cards);
+    },
+    fitDeliveries(deliveries = config.deliveries) {
+      const next = fitCardDeliveries(store.getState(), deliveries);
+      if (next !== store.getState()) commit(next);
+    },
+    roomLeft: () => sourceRoomLeft(store.getState(), config.max),
+    totalChars: () => selectTotalChars(store.getState()),
+    settled: () => selectSettled(store.getState())
+  };
+  return controller;
+}
+
+// sources/runtime/intake.ts
+var import_associations = require("@ai-matrx/associations");
+var TRANSCRIPT_NAME_MAX = 120;
+function sourceAttachTargets(attachTo) {
+  return attachTo ? [
+    {
+      entity_type: attachTo.entityType,
+      entity_id: attachTo.entityId,
+      // The EDGE's label, which the registry names (a deck's Source is its
+      // "source", a scope's is "about") — never the target's display name,
+      // which the door refused as an unknown label (USI-3e).
+      label: null,
+      signal: true
+    }
+  ] : [];
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname.replace(/^www\./, "");
+  } catch {
+    return url;
+  }
+}
+function isSaveItNotice(remedy) {
+  return typeof remedy === "string" && remedy.startsWith("save_it");
+}
+function landedNotes(notices) {
+  return (notices ?? []).map((n) => n.message).filter(Boolean);
+}
+function registeredFileEdge(targetType) {
+  if ((0, import_associations.isRegisteredPair)("file", targetType)) return "file_to_target";
+  if ((0, import_associations.isRegisteredPair)(targetType, "file")) return "target_to_file";
+  return null;
+}
+function createSourceIntake(set, deps) {
+  const { doors } = deps;
+  const attachTo = sourceAttachTargets(deps.attachTo);
+  const hold = (run) => deps.holdIntent ? deps.holdIntent(run) : run();
+  const notFiledSuffix = attachTo.length ? " or filed with what you are making" : "";
+  const failOrHold = (id, err) => {
+    set.fail(id, deps.waitsForOrganization(err) ? WAITING_FOR_ORGANIZATION : deps.failureSentence(err));
+  };
+  const needUser = () => {
+    const userId = deps.userId();
+    if (!userId) throw new Error("Your sign-in is still loading, so nothing was added. Try again in a moment.");
+    return userId;
+  };
+  const landText = async (body) => {
+    const landed = await doors.land({ ...body, keep: true, attach_to: attachTo });
+    return { id: landed.processed_document_id, notes: landedNotes(landed.notices) };
+  };
+  const landPaste = async (id, trimmed, name) => {
+    try {
+      const organizationId = await deps.ensureOrganization();
+      const body = await doors.buildTextLanding({ text: trimmed, name, organizationId, userId: needUser() });
+      const landed = await landText(body);
+      set.settle(id, {
+        label: body.name,
+        ref: createSourceRef("processed_document", landed.id),
+        processedDocumentId: landed.id,
+        notes: landed.notes
+      });
+    } catch (err) {
+      failOrHold(id, err);
+    }
+  };
+  const landWebPage = async (id, url) => {
+    try {
+      const organizationId = await deps.ensureOrganization();
+      const result = await doors.scrapeUrl(url);
+      if (!result) {
+        set.fail(
+          id,
+          "That page could not be read \u2014 it may need a sign-in or block robots. Try another link, or copy the text and use Paste text."
+        );
+        return;
+      }
+      if (!result.processedDocumentId) {
+        set.fail(
+          id,
+          result.sourceNotices[0]?.message ?? "The page was read but did not become a Source, and the server did not say why. Try again."
+        );
+        return;
+      }
+      let notes;
+      try {
+        const kept = await doors.keep(result.processedDocumentId, { attachTo, organizationId });
+        notes = [
+          ...landedNotes(result.sourceNotices.filter((n) => !isSaveItNotice(n.remedy))),
+          ...landedNotes(kept.notices)
+        ];
+      } catch (err) {
+        notes = [
+          ...landedNotes(result.sourceNotices),
+          `It is in your Sources, but it could not be kept for reuse${notFiledSuffix}: ${deps.failureSentence(err)}`
+        ];
+      }
+      set.settle(id, {
+        label: result.pageTitle || hostOf(url),
+        ref: createSourceRef("processed_document", result.processedDocumentId),
+        processedDocumentId: result.processedDocumentId,
+        notes
+      });
+    } catch (err) {
+      failOrHold(id, err);
+    }
+  };
+  const landYouTube = async (id, url, videoId) => {
+    try {
+      const organizationId = await deps.ensureOrganization();
+      const { text, note, source } = await doors.fetchYouTubeTranscript(url);
+      if (!text) {
+        set.fail(
+          id,
+          note ?? "That video has no speech we could write out (no captions and no clear voice). Try another video, or paste a transcript."
+        );
+        return;
+      }
+      if (source) {
+        const label = `YouTube \u2014 ${source.title || videoId}`.slice(0, TRANSCRIPT_NAME_MAX);
+        let notes = [];
+        try {
+          const kept = await doors.keep(source.processed_document_id, { attachTo, organizationId });
+          notes = landedNotes(kept.notices);
+        } catch (err) {
+          notes = [
+            `It was read, but its Source could not be kept for reuse${notFiledSuffix}: ${deps.failureSentence(err)}`
+          ];
+        }
+        set.settle(id, {
+          label,
+          ref: createSourceRef("processed_document", source.processed_document_id),
+          processedDocumentId: source.processed_document_id,
+          notes
+        });
+        return;
+      }
+      const name = `YouTube \u2014 ${text.split(/\s+/).slice(0, 10).join(" ")}\u2026`.slice(0, TRANSCRIPT_NAME_MAX);
+      const body = await doors.buildTextLanding({ text, name, organizationId, userId: needUser() });
+      const landed = await landText({
+        ...body,
+        // Identity is the video, so the same video twice is one Source.
+        canonical_identity: `youtube:${videoId}`,
+        provenance: { ...body.provenance ?? {}, origin_client: "youtube", capture_method: "captions", final_url: url }
+      });
+      set.settle(id, {
+        label: name,
+        ref: createSourceRef("processed_document", landed.id),
+        processedDocumentId: landed.id,
+        // Untimed: say why it has no parts to choose (the server's own sentence).
+        notes: note ? [...landed.notes, note] : landed.notes
+      });
+    } catch (err) {
+      failOrHold(id, err);
+    }
+  };
+  const fileAgainstTarget = async (fileId, organizationId) => {
+    const target = deps.attachTo;
+    if (!target) return null;
+    const what = target.label ? `"${target.label}"` : "what you are making";
+    const direction = registeredFileEdge(target.entityType);
+    const cannot = `It was uploaded, but a file cannot be filed with ${what} (a ${target.entityType.replace(/_/g, " ")}), so it is not listed there.`;
+    if (!direction) return cannot;
+    if (direction === "file_to_target" && !(0, import_associations.isAssociationTargetType)(target.entityType)) return cannot;
+    const linked = await doors.associate(
+      direction === "file_to_target" ? {
+        sourceType: "file",
+        sourceId: fileId,
+        targetType: target.entityType,
+        targetId: target.entityId,
+        orgId: organizationId
+      } : {
+        sourceType: target.entityType,
+        sourceId: target.entityId,
+        targetType: "file",
+        targetId: fileId,
+        orgId: organizationId
+      }
+    );
+    return linked.ok ? null : `It was uploaded, but it could not be filed with ${what}: ${linked.error.message}`;
+  };
+  const fileNotes = async (fileId) => {
+    try {
+      const organizationId = await deps.ensureOrganization();
+      const filed = await fileAgainstTarget(fileId, organizationId);
+      return filed ? [filed] : [];
+    } catch (err) {
+      return deps.waitsForOrganization(err) ? [] : [`It was uploaded, but it could not be filed: ${deps.failureSentence(err)}`];
+    }
+  };
+  const transcribeRecording = async (id, fileId, fileName) => {
+    try {
+      const organizationId = await deps.ensureOrganization();
+      const transcription = await doors.transcribeFile({ fileId, organizationId });
+      const text = (transcription.text ?? "").trim();
+      if (text.length < 8) {
+        set.fail(
+          id,
+          "We couldn't hear enough speech in that recording to write it out. Try a recording with a clear voice."
+        );
+        return;
+      }
+      const name = `Recording \u2014 ${fileName}`.slice(0, TRANSCRIPT_NAME_MAX);
+      const body = await doors.buildTextLanding({ text, name, organizationId, userId: needUser() });
+      const landed = await landText({
+        ...body,
+        canonical_identity: `audio-transcript:${fileId}`,
+        provenance: { ...body.provenance ?? {}, origin_client: "transcription", capture_method: "speech" }
+      });
+      set.settle(id, {
+        label: name,
+        ref: createSourceRef("processed_document", landed.id),
+        processedDocumentId: landed.id,
+        fileId,
+        notes: landed.notes
+      });
+    } catch (err) {
+      failOrHold(id, err);
+    }
+  };
+  const intake = {
+    async addPastedText(text, name) {
+      const trimmed = text.trim();
+      if (!trimmed) return;
+      const max = deps.maxKeptChars();
+      const kept = max !== null && trimmed.length <= max;
+      const id = set.addPending({
+        kind: "paste",
+        label: name?.trim() || "Pasted text",
+        input: kept ? { text: trimmed, name } : void 0,
+        notes: kept ? void 0 : [NOT_KEPT_FOR_RELOAD]
+      });
+      await hold(() => landPaste(id, trimmed, name));
+    },
+    async addWebPage(raw) {
+      const url = /^https?:\/\//i.test(raw.trim()) ? raw.trim() : `https://${raw.trim()}`;
+      const id = set.addPending({ kind: "web", label: hostOf(url), origin: url, input: { url } });
+      await hold(() => landWebPage(id, url));
+    },
+    async addScrapedPage(page) {
+      const label = page.title || hostOf(page.url);
+      if (!page.processedDocumentId) {
+        const id2 = set.addPending({ kind: "web", label, origin: page.url, input: { url: page.url } });
+        await hold(() => landPaste(id2, page.text, label));
+        return;
+      }
+      const pdId = page.processedDocumentId;
+      const id = set.addPending({ kind: "web", label, origin: page.url, input: { url: page.url } });
+      await hold(async () => {
+        let notes = [];
+        try {
+          const organizationId = await deps.ensureOrganization();
+          const kept = await doors.keep(pdId, { attachTo, organizationId });
+          notes = landedNotes(kept.notices);
+        } catch (err) {
+          notes = deps.waitsForOrganization(err) ? [KEEP_WAITING_FOR_ORGANIZATION] : [`It is in your Sources, but it could not be kept for reuse${notFiledSuffix}: ${deps.failureSentence(err)}`];
+        }
+        set.settle(id, {
+          label,
+          ref: createSourceRef("processed_document", pdId),
+          processedDocumentId: pdId,
+          notes
+        });
+      });
+    },
+    async addUploaded(files, kind) {
+      for (const file of files) {
+        if (set.hasRef("file", file.fileId)) continue;
+        const id = set.addPending({ kind, label: file.name, origin: "Uploaded file", fileId: file.fileId });
+        const notes = await fileNotes(file.fileId);
+        set.settle(id, { label: file.name, ref: createSourceRef("file", file.fileId), fileId: file.fileId, notes });
+      }
+    },
+    async addUploadedRecording(file) {
+      const id = set.addPending({
+        kind: "audio",
+        label: file.name,
+        origin: "Recording",
+        fileId: file.fileId,
+        input: { fileId: file.fileId }
+      });
+      await hold(() => transcribeRecording(id, file.fileId, file.name));
+    },
+    addExisting(item) {
+      if (set.hasRef(item.token, item.id)) return false;
+      set.addReady({
+        kind: draftKindForToken(item.token),
+        label: item.title,
+        ref: createSourceRef(item.token, item.id),
+        fileId: item.token === "file" ? item.id : void 0,
+        processedDocumentId: item.token === "processed_document" ? item.id : void 0
+      });
+      return true;
+    },
+    async addYouTube(raw) {
+      const url = raw.trim();
+      const videoId = deps.youtubeId(url);
+      if (!videoId) return;
+      const id = set.addPending({ kind: "youtube", label: "YouTube video", origin: url, input: { url } });
+      await hold(() => landYouTube(id, url, videoId));
+    },
+    resume(card) {
+      const input = resumableInput(card.draft);
+      if (!input) return false;
+      set.restart(card.id);
+      switch (card.draft.kind) {
+        case "paste":
+          void landPaste(card.id, (input.text ?? "").trim(), input.name);
+          return true;
+        case "web":
+          void landWebPage(card.id, input.url ?? "");
+          return true;
+        case "youtube": {
+          const videoId = deps.youtubeId(input.url ?? "");
+          if (!videoId) {
+            set.fail(card.id, "That link is not a YouTube video any more. Remove it and paste the link again.");
+            return true;
+          }
+          void landYouTube(card.id, input.url ?? "", videoId);
+          return true;
+        }
+        case "audio":
+          void transcribeRecording(card.id, input.fileId ?? "", card.draft.label);
+          return true;
+        default:
+          return false;
+      }
+    },
+    async retryFile(card, file) {
+      set.restart(card.id);
+      set.updateDraft(card.id, { label: file.name, fileId: file.fileId });
+      if (card.draft.kind === "audio") {
+        set.updateDraft(card.id, { input: { fileId: file.fileId } });
+        await hold(() => transcribeRecording(card.id, file.fileId, file.name));
+        return;
+      }
+      const notes = await fileNotes(file.fileId);
+      set.settle(card.id, { label: file.name, ref: createSourceRef("file", file.fileId), fileId: file.fileId, notes });
+    },
+    async fileLanded(card, processedDocumentId) {
+      const notes = (card.draft.notes ?? []).filter((n) => n !== KEEP_WAITING_FOR_ORGANIZATION);
+      set.updateDraft(card.id, { processedDocumentId, notes });
+      try {
+        const organizationId = await deps.ensureOrganization();
+        await doors.keep(processedDocumentId, { attachTo, organizationId });
+      } catch (err) {
+        if (deps.waitsForOrganization(err)) {
+          set.updateDraft(card.id, { processedDocumentId, notes: [...notes, KEEP_WAITING_FOR_ORGANIZATION] });
+          return;
+        }
+        set.updateDraft(card.id, {
+          processedDocumentId,
+          notes: [
+            ...notes,
+            `It was read, but its Source could not be kept for reuse${notFiledSuffix}: ${deps.failureSentence(err)}`
+          ]
+        });
+      }
+    }
+  };
+  return intake;
+}
+
+// sources/runtime/recovery.ts
+var GUARDS = /* @__PURE__ */ Symbol.for("ai-matrx.agents.sources.recovery-guards");
+function sourceRecoveryGuards() {
+  const slot = globalThis;
+  let guards = slot[GUARDS];
+  if (!guards) {
+    guards = { resumedCards: /* @__PURE__ */ new Set(), keptFileSources: /* @__PURE__ */ new Set(), startedFileRuns: /* @__PURE__ */ new Set() };
+    slot[GUARDS] = guards;
+  }
+  return guards;
+}
+function cardsToResume(cards) {
+  return cards.filter((c) => c.status === "error" && c.error === RELOADED_RESUMING);
+}
+function resumeInterrupted(cards, intake) {
+  const { resumedCards } = sourceRecoveryGuards();
+  for (const card of cardsToResume(cards)) {
+    if (resumedCards.has(card.id)) continue;
+    resumedCards.add(card.id);
+    intake.resume(card);
+  }
+}
+function cardsWaitingForOrganization(cards) {
+  return cards.filter(
+    (s) => s.status === "error" && s.error === WAITING_FOR_ORGANIZATION || !!s.draft.processedDocumentId && !!s.draft.notes?.includes(KEEP_WAITING_FOR_ORGANIZATION)
+  );
+}
+function continueAfterOrganization(cards, intake) {
+  for (const card of cards) {
+    if (card.status === "error" && card.error === WAITING_FOR_ORGANIZATION) {
+      intake.resume(card);
+    } else if (card.draft.processedDocumentId && card.draft.notes?.includes(KEEP_WAITING_FOR_ORGANIZATION)) {
+      void intake.fileLanded(card, card.draft.processedDocumentId);
+    }
+  }
+}
+function isAskableFileCard(card, deps) {
+  return isWaitingFileCard(card) && !fileCardHeldForOrganization(card, deps.organizationId, deps.fileOrganizationId);
+}
+async function lookAtFileCards(cards, ctx) {
+  const { keptFileSources, startedFileRuns } = sourceRecoveryGuards();
+  let anyWaiting = false;
+  for (const card of cards.filter((c) => isAskableFileCard(c, ctx))) {
+    const fileId = card.draft.fileId;
+    const guard = `${card.id}:${fileId}`;
+    if (keptFileSources.has(guard)) continue;
+    let status = null;
+    try {
+      status = await ctx.readFileState(fileId, ctx.signal);
+    } catch {
+      if (ctx.signal.aborted) return false;
+      anyWaiting = true;
+      continue;
+    }
+    if (ctx.signal.aborted) return false;
+    const localJob = ctx.runner.jobs.find((j) => j.cldFileId === fileId) ?? null;
+    const step = nextFileStep(status, {
+      started: startedFileRuns.has(guard),
+      localRunning: localJob?.status === "running"
+    });
+    const localPdId = localJob?.processedDocumentId ?? null;
+    if (step.do === "keep" || localPdId) {
+      keptFileSources.add(guard);
+      const pdId = step.do === "keep" ? step.processedDocumentId : localPdId;
+      await ctx.intake.fileLanded(card, pdId);
+      void ctx.set.manifest();
+    } else if (step.do === "start") {
+      startedFileRuns.add(guard);
+      anyWaiting = true;
+      void ctx.runner.runForCldFile(fileId, card.draft.label, "Reading it into a Source").catch(() => void 0);
+    } else if (step.do === "unreadable") {
+      keptFileSources.add(guard);
+      ctx.set.fail(card.id, step.reason);
+    } else {
+      anyWaiting = true;
+    }
+  }
+  return anyWaiting;
+}
+//# sourceMappingURL=index.cjs.map