@heynixie/contract 0.0.0-stage → 0.54.0

package/dist/index.js

@@ -0,0 +1,1097 @@
+// src/has-several-words.ts
+function hasSeveralWords(text) {
+  return /\S\s+\S/u.test(text);
+}
+
+// src/pick-span-source.ts
+var pastedInputTypes = new Set(["insertFromPaste", "insertFromPasteAsQuotation"]);
+var typedInputTypes = new Set([
+  "insertCompositionText",
+  "insertLineBreak",
+  "insertParagraph",
+  "insertReplacementText",
+  "insertText"
+]);
+var wordInputTypes = new Set(["insertCompositionText", "insertText"]);
+function pickSpanSource(inputType, data) {
+  if (pastedInputTypes.has(inputType)) {
+    return "pasted";
+  }
+  if (inputType === "insertFromDrop") {
+    return "dropped";
+  }
+  if (wordInputTypes.has(inputType) && data !== null && hasSeveralWords(data)) {
+    return "unknown";
+  }
+  if (typedInputTypes.has(inputType)) {
+    return "typed";
+  }
+  return "unknown";
+}
+
+// src/build-pending-input.ts
+function buildPendingInput(fields) {
+  const pending = {
+    selection: {
+      backward: fields.inputType.endsWith("Backward"),
+      end: fields.selectionEnd,
+      start: fields.selectionStart
+    },
+    source: pickSpanSource(fields.inputType, fields.data)
+  };
+  return fields.inputType === "insertText" && fields.data !== null && hasSeveralWords(fields.data) ? { ...pending, respacing: fields.data } : pending;
+}
+// src/build-query-utils.ts
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+function buildQueryUtils(client) {
+  return createTanstackQueryUtils(client, { path: ["nixie"] });
+}
+// src/build-span-state.ts
+function buildSpanState(state, pending, text) {
+  const pinned = planEdit(state.text, text, pending?.selection);
+  const fallback = pending === undefined || !isEditAtSelection(pinned, pending.selection);
+  const edit = fallback ? planEdit(state.text, text) : pinned;
+  const source = fallback ? "unknown" : pickEditSource(state.removed, pending, {
+    at: edit.at,
+    removed: edit.removed,
+    text: text.slice(edit.at, edit.at + edit.inserted)
+  });
+  const spans = state.spans.flatMap((span) => splitSpan(span, edit));
+  if (edit.inserted > 0) {
+    spans.push({ end: edit.at + edit.inserted, source, start: edit.at });
+  }
+  const removed = fallback ? undefined : findTypedRemoval(state, edit);
+  return removed === undefined ? { spans: mergeSpans(spans), text } : { removed, spans: mergeSpans(spans), text };
+}
+function planEdit(before, after, selection) {
+  const shorter = Math.min(before.length, after.length);
+  const prefixBound = Math.min(shorter, selection?.start ?? shorter);
+  const suffixBound = Math.min(shorter, before.length - (selection?.end ?? 0));
+  if (selection?.backward === true) {
+    const suffix = countSuffix(before, after, suffixBound);
+    return buildEdit(before, after, {
+      prefix: countPrefix(before, after, Math.min(prefixBound, shorter - suffix)),
+      suffix
+    });
+  }
+  const prefix = countPrefix(before, after, prefixBound);
+  return buildEdit(before, after, {
+    prefix,
+    suffix: countSuffix(before, after, Math.min(suffixBound, shorter - prefix))
+  });
+}
+function countSuffix(before, after, limit) {
+  let length = 0;
+  while (length < limit && before[before.length - 1 - length] === after[after.length - 1 - length]) {
+    length += 1;
+  }
+  return length > 0 && (isLowSurrogateAt(before, before.length - length) || isLowSurrogateAt(after, after.length - length)) ? length - 1 : length;
+}
+function isLowSurrogateAt(text, index) {
+  const code = text.codePointAt(index) ?? 0;
+  return code >= 56320 && code <= 57343;
+}
+function buildEdit(before, after, shared) {
+  return {
+    at: shared.prefix,
+    inserted: after.length - shared.prefix - shared.suffix,
+    removed: before.length - shared.prefix - shared.suffix
+  };
+}
+function countPrefix(before, after, limit) {
+  let length = 0;
+  while (length < limit && before[length] === after[length]) {
+    length += 1;
+  }
+  return length > 0 && (isLowSurrogateAt(before, length) || isLowSurrogateAt(after, length)) ? length - 1 : length;
+}
+function isEditAtSelection(edit, selection) {
+  return edit.inserted === 0 || edit.at === selection.start && edit.at + edit.removed === selection.end;
+}
+function pickEditSource(removed, pending, insertion) {
+  const respacing = pending.respacing;
+  const isRespaced = respacing !== undefined && removed !== undefined && insertion.at === removed.at && insertion.removed === 0 && insertion.text === respacing && stripWhitespace(respacing) === stripWhitespace(removed.text);
+  return isRespaced ? "typed" : pending.source;
+}
+function stripWhitespace(text) {
+  return text.replaceAll(/\s/gu, "");
+}
+function splitSpan(span, edit) {
+  const removedEnd = edit.at + edit.removed;
+  const shift = edit.inserted - edit.removed;
+  if (span.end <= edit.at) {
+    return [span];
+  }
+  if (span.start >= removedEnd) {
+    return [{ ...span, end: span.end + shift, start: span.start + shift }];
+  }
+  const head = span.start < edit.at ? [{ ...span, end: edit.at }] : [];
+  const tail = span.end > removedEnd ? [{ ...span, end: span.end + shift, start: edit.at + edit.inserted }] : [];
+  return [...head, ...tail];
+}
+function findTypedRemoval(state, edit) {
+  const end = edit.at + edit.removed;
+  const isTyped = state.spans.some((span) => span.source === "typed" && span.start <= edit.at && end <= span.end);
+  return edit.inserted === 0 && edit.removed > 0 && isTyped ? { at: edit.at, text: state.text.slice(edit.at, end) } : undefined;
+}
+function mergeSpans(spans) {
+  const merged = [];
+  for (const span of spans.toSorted((left, right) => left.start - right.start)) {
+    const last = merged.at(-1);
+    if (last?.source === span.source && last.end === span.start) {
+      last.end = span.end;
+    } else if (span.end > span.start) {
+      merged.push({ ...span });
+    }
+  }
+  return merged;
+}
+// src/client-header-name.ts
+var clientHeaderName = "x-nixie-client";
+// src/contract.ts
+import { eventIterator as eventIterator2, oc as oc2 } from "@orpc/contract";
+import { z as z9 } from "zod";
+
+// src/image-limits.ts
+var imageLimits = {
+  count: 4,
+  bytes: 5 * 1024 * 1024,
+  longEdge: 1568,
+  mediaTypes: ["image/jpeg", "image/png", "image/webp", "image/gif"]
+};
+
+// src/image-not-found-error.ts
+var imageNotFoundError = {
+  message: "No readable image of a message has this position",
+  status: 404
+};
+
+// src/image-refused-error.ts
+import { z } from "zod";
+var imageRefusedDataSchema = z.object({
+  position: z.int().nonnegative().nullable(),
+  reason: z.enum(["too_many", "too_large", "unsupported_type"])
+});
+var imageRefusedError = {
+  message: "An image is too large, of a type nixie does not take, or one too many",
+  status: 422,
+  data: imageRefusedDataSchema
+};
+
+// src/memory-view-contract.ts
+import { z as z5 } from "zod";
+
+// src/memory-export-contract.ts
+import { eventIterator } from "@orpc/contract";
+import { z as z2 } from "zod";
+
+// src/reused-id-errors.ts
+var reusedIDErrors = {
+  CLIENT_ACTION_ID_REUSED: {
+    message: "The client action ID belongs to a different action",
+    status: 409
+  }
+};
+
+// src/signed-in.ts
+import { oc } from "@orpc/contract";
+var signedIn = oc.errors({
+  UNAUTHORIZED: { message: "The device session is missing, lapsed or revoked", status: 401 }
+});
+
+// src/memory-export-contract.ts
+var checkedExport = signedIn.errors(reusedIDErrors).errors({
+  MEMORY_NOT_STARTED: { message: "The memory store has not started yet", status: 503 }
+});
+var exportEvent = z2.union([
+  z2.object({ chunk: z2.string() }),
+  z2.object({ isComplete: z2.literal(true) })
+]);
+var exportEvents = eventIterator(exportEvent);
+var memoryExportContract = {
+  export: checkedExport.input(z2.object({ clientActionID: z2.uuid() })).output(exportEvents)
+};
+
+// src/moment-contract.ts
+import { z as z3 } from "zod";
+var momentView = signedIn.errors({
+  MEMORY_NOT_STARTED: { message: "The memory store has not started yet", status: 503 },
+  MOMENT_NOT_FOUND: { message: "No moment has this ID", status: 404 },
+  STALE_VERSION: { message: "The moment has moved past that version", status: 409 }
+});
+var momentIDSchema = z3.string().min(1).max(200);
+var momentTargetSchema = z3.object({ momentID: momentIDSchema, version: z3.int().positive() });
+var reflectionSchema = z3.object({
+  model: z3.string(),
+  text: z3.string().nullable(),
+  writtenAt: z3.date()
+});
+var destroyPreviewSchema = z3.object({
+  keptAt: z3.date(),
+  keptBy: z3.enum(["owner", "model"]),
+  kept: z3.object({ records: z3.int().nonnegative() }),
+  lost: z3.object({ links: z3.int().nonnegative(), texts: z3.int().nonnegative() }),
+  momentID: z3.string(),
+  note: z3.string().nullable(),
+  reflections: z3.array(reflectionSchema),
+  shortID: z3.string(),
+  state: z3.enum(["active", "retired"]),
+  thread: z3.string(),
+  title: z3.string().nullable(),
+  version: z3.int().positive()
+});
+var momentKeep = signedIn.errors(reusedIDErrors).errors({
+  MEMORY_NOT_STARTED: { message: "The memory store has not started yet", status: 503 },
+  BAD_SPAN: {
+    message: "The span needs a first and a last record on the thread, in order",
+    status: 422
+  }
+});
+var titleSchema = z3.string().min(1).max(120).regex(/\S/u);
+var keepSchema = z3.object({
+  clientActionID: z3.uuid(),
+  firstSequence: z3.int().nonnegative(),
+  lastSequence: z3.int().nonnegative(),
+  thread: z3.string().min(1).max(200),
+  title: titleSchema
+});
+var momentSummarySchema = z3.object({
+  editedAt: z3.date().nullable(),
+  keptAt: z3.date(),
+  keptBy: z3.enum(["owner", "model"]),
+  momentID: z3.string(),
+  shortID: z3.string(),
+  state: z3.enum(["active", "retired"]),
+  title: z3.string().nullable()
+});
+var momentListSchema = z3.object({
+  before: z3.int().nonnegative().optional(),
+  includeRetired: z3.boolean(),
+  query: z3.string().max(500).optional()
+});
+var linkSchema = z3.object({
+  itemID: z3.string(),
+  shortID: z3.string(),
+  text: z3.string().nullable()
+});
+var noteSchema = z3.object({ text: z3.string(), writtenAt: z3.date() });
+var shownReflectionSchema = reflectionSchema.extend({ reflectionID: z3.string() });
+var momentDetailSchema = momentSummarySchema.extend({
+  firstSequence: z3.int().nonnegative(),
+  lastSequence: z3.int().nonnegative(),
+  links: z3.array(linkSchema),
+  note: noteSchema.nullable(),
+  reflections: z3.array(shownReflectionSchema),
+  thread: z3.string(),
+  titleBy: z3.enum(["owner", "model"]),
+  version: z3.int().positive()
+});
+var spanRecordSchema = z3.object({
+  isGap: z3.boolean(),
+  kind: z3.string(),
+  recordedAt: z3.date(),
+  sequence: z3.int().nonnegative(),
+  text: z3.string().nullable(),
+  tool: z3.string().nullable()
+});
+var momentChangeSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("title"), title: titleSchema }),
+  z3.object({
+    kind: z3.literal("edges"),
+    firstSequence: z3.int().nonnegative(),
+    lastSequence: z3.int().nonnegative()
+  }),
+  z3.object({ kind: z3.literal("note"), note: z3.string().min(1).max(4000).regex(/\S/u) }),
+  z3.object({ kind: z3.literal("reflection_removed"), reflectionID: z3.string().min(1).max(200) })
+]);
+var momentChange = momentView.errors(reusedIDErrors);
+var momentContract = {
+  keepMoment: momentKeep.input(keepSchema).output(z3.object({ momentID: z3.string(), shortID: z3.string() })),
+  listMoments: signedIn.errors({
+    MEMORY_NOT_STARTED: { message: "The memory store has not started yet", status: 503 }
+  }).input(momentListSchema).output(z3.object({ moments: z3.array(momentSummarySchema), next: z3.int().nonnegative().nullable() })),
+  readMoment: momentView.input(z3.object({ momentID: momentIDSchema })).output(momentDetailSchema),
+  readMomentSpan: momentView.input(z3.object({ momentID: momentIDSchema, after: z3.int().nonnegative().optional() })).output(z3.object({ records: z3.array(spanRecordSchema), next: z3.int().nonnegative().nullable() })),
+  editMoment: momentChange.errors({
+    BAD_SPAN: {
+      message: "The span needs a first and a last record on the thread, in order",
+      status: 422
+    },
+    REFLECTION_NOT_FOUND: { message: "The moment has no reflection with this ID", status: 404 }
+  }).input(momentTargetSchema.extend({ clientActionID: z3.uuid(), change: momentChangeSchema })).output(z3.object({ momentID: z3.string(), version: z3.int().positive() })),
+  linkMoment: momentChange.errors({
+    MEMORY_ITEM_NOT_FOUND: { message: "No memory item has this ID", status: 404 },
+    ALREADY_LINKED: { message: "The item is already linked to the moment", status: 409 },
+    NOT_LINKED: { message: "The item is not linked to the moment", status: 409 }
+  }).input(momentTargetSchema.extend({
+    clientActionID: z3.uuid(),
+    isLinked: z3.boolean(),
+    itemID: z3.string().min(1).max(200)
+  })).output(z3.object({ momentID: z3.string(), version: z3.int().positive() })),
+  previewMomentDestroy: momentView.input(momentTargetSchema).output(destroyPreviewSchema),
+  destroyMoment: momentView.errors(reusedIDErrors).input(momentTargetSchema.extend({ clientActionID: z3.uuid() })).output(z3.object({ momentID: z3.string() }))
+};
+
+// src/proposal-outcome-schema.ts
+import { z as z4 } from "zod";
+var closeMatchSchema = z4.object({
+  itemID: z4.string(),
+  text: z4.string(),
+  version: z4.int().positive()
+});
+var proposalOutcomeSchema = z4.discriminatedUnion("status", [
+  z4.object({ proposalID: z4.string(), status: z4.literal("applied") }),
+  z4.object({ proposalID: z4.string(), status: z4.literal("rejected") }),
+  z4.object({
+    item: closeMatchSchema,
+    proposalID: z4.string(),
+    status: z4.literal("close_match")
+  }),
+  z4.object({
+    cause: z4.enum(["lapsed", "answered", "moved", "changed", "gone"]),
+    proposalID: z4.string(),
+    status: z4.literal("stale")
+  }),
+  z4.object({
+    code: z4.enum([
+      "CLIENT_ACTION_ID_REUSED",
+      "PIN_EDIT",
+      "PINNED_CORE_FULL",
+      "RETIREMENT_EDIT",
+      "REVISION_TARGET",
+      "WRONG_STATE"
+    ]),
+    proposalID: z4.string(),
+    status: z4.literal("refused")
+  })
+]);
+
+// src/memory-view-contract.ts
+var memoryView = signedIn.errors({
+  MEMORY_NOT_STARTED: { message: "The memory store has not started yet", status: 503 }
+});
+var memoryChange = memoryView.errors(reusedIDErrors).errors({
+  MEMORY_ITEM_NOT_FOUND: { message: "No memory item has this ID", status: 404 },
+  STALE_VERSION: { message: "The memory item has moved past that version", status: 409 },
+  WRONG_STATE: { message: "The memory item is not in a state that change takes", status: 409 }
+});
+var itemIDSchema = z5.string().min(1).max(200);
+var itemTextSchema = z5.string().max(2000).regex(/\S/u);
+var proposalOriginSchema = z5.enum(["owner", "conversation", "task", "memory_writer"]);
+var originSchema = z5.enum([...proposalOriginSchema.options, "lapse"]);
+var sourceSchema = z5.enum(["owner", "owner_data", "untrusted"]);
+var subjectSchema = z5.enum(["owner", "self", "shared"]);
+var kindSchema = z5.enum(["fact", "self"]);
+var memoryItemSchema = z5.object({
+  changedAt: z5.date(),
+  createdAt: z5.date(),
+  forgottenAt: z5.date().nullable(),
+  isPinned: z5.boolean(),
+  isSensitive: z5.boolean(),
+  itemID: z5.string(),
+  kind: kindSchema,
+  origin: originSchema,
+  shortID: z5.string(),
+  source: sourceSchema,
+  state: z5.enum(["active", "retired", "forgetting", "forgotten"]),
+  status: z5.enum(["readable", "shredded", "unreadable"]),
+  subject: subjectSchema,
+  text: z5.string().optional(),
+  until: z5.date().nullable(),
+  version: z5.int().positive()
+});
+var memoryMatchSchema = memoryItemSchema.extend({
+  score: z5.number().optional(),
+  similarity: z5.number().optional()
+});
+var evidenceSchema = z5.object({
+  end: z5.int().nonnegative(),
+  message: z5.object({
+    status: z5.enum(["readable", "shredded", "unreadable", "missing"]),
+    text: z5.string().optional()
+  }).nullable(),
+  sequence: z5.int().nonnegative(),
+  start: z5.int().nonnegative()
+});
+var ownerImageSchema = z5.object({
+  position: z5.int().nonnegative(),
+  sequence: z5.int().positive(),
+  thread: z5.string()
+});
+var memoryVersionSchema = z5.object({
+  change: z5.enum(["created", "edited", "retired", "restored", "undone"]),
+  checkerModel: z5.string().nullable(),
+  checks: z5.record(z5.string(), z5.unknown()).nullable(),
+  evidence: evidenceSchema.nullable(),
+  evidenceQuote: z5.string().nullable(),
+  image: ownerImageSchema.nullable(),
+  origin: originSchema,
+  proposalID: z5.string().nullable(),
+  recordedAt: z5.date(),
+  source: sourceSchema,
+  state: z5.enum(["active", "retired"]),
+  status: z5.enum(["readable", "shredded", "unreadable"]),
+  taskID: z5.string().nullable(),
+  text: z5.string().optional(),
+  version: z5.int().positive(),
+  writerModel: z5.string().nullable()
+});
+var reviewReasonSchema = z5.enum([
+  "no_quote",
+  "quote_not_typed",
+  "quote_in_quoted_block",
+  "invisible_character",
+  "token_missing",
+  "checker_not_asserted",
+  "checker_unsure",
+  "checker_unreachable",
+  "forgotten_evidence",
+  "ambiguous_target",
+  "pinned",
+  "other",
+  "self_note",
+  "from_photo",
+  "sensitive"
+]);
+var proposalSourceSchema = z5.object({
+  origin: proposalOriginSchema,
+  proposedAt: z5.date(),
+  thread: z5.string().nullable()
+});
+var memoryProposalSchema = z5.object({
+  actionHash: z5.string(),
+  createdAt: z5.date(),
+  evidence: evidenceSchema.nullable(),
+  image: ownerImageSchema.nullable(),
+  isPinned: z5.boolean(),
+  isSensitive: z5.boolean(),
+  itemID: z5.string(),
+  kind: kindSchema,
+  lapseAt: z5.date(),
+  operation: z5.enum(["remember", "retire", "pin"]),
+  origin: proposalOriginSchema,
+  proposalID: z5.string(),
+  quote: z5.string().nullable(),
+  reason: reviewReasonSchema,
+  source: sourceSchema,
+  sources: z5.array(proposalSourceSchema),
+  subject: subjectSchema,
+  targetVersion: z5.int().positive().nullable(),
+  text: z5.string(),
+  until: z5.date().nullable()
+});
+var proposalAnswerSchema = z5.object({
+  actionHash: z5.string().min(1).max(200),
+  clientActionID: z5.uuid(),
+  proposalID: z5.string().min(1).max(200)
+});
+var revisionTargetSchema = z5.object({ itemID: itemIDSchema, version: z5.int().positive() });
+var approvalAnswerSchema = proposalAnswerSchema.extend({
+  editedText: itemTextSchema.optional(),
+  ignoreCloseMatch: z5.boolean().optional(),
+  revisionOf: revisionTargetSchema.optional()
+});
+var rejectionReasonSchema = z5.string().max(500).regex(/\S/u);
+var rejectionAnswerSchema = proposalAnswerSchema.extend({
+  reason: rejectionReasonSchema.optional()
+});
+var proposalOutcomesSchema = z5.object({ outcomes: z5.array(proposalOutcomeSchema) });
+var memoryItemDetailSchema = memoryItemSchema.extend({ versions: z5.array(memoryVersionSchema) });
+var forgetLossSchema = z5.object({
+  evidenceMessages: z5.int().nonnegative(),
+  proposals: z5.int().nonnegative()
+});
+var forgetPreviewSchema = memoryItemDetailSchema.extend({ lost: forgetLossSchema });
+var retiredForgetPreviewSchema = z5.object({
+  hasMore: z5.boolean(),
+  items: z5.array(memoryItemSchema.extend({ lost: forgetLossSchema }))
+});
+var retiredForgetSchema = z5.object({
+  clientActionID: z5.uuid(),
+  targets: z5.array(revisionTargetSchema).min(1).max(100).refine((targets) => new Set(targets.map((target) => target.itemID)).size === targets.length, {
+    message: "Each item appears once"
+  })
+});
+var forgetStatusSchema = z5.object({
+  deleted: z5.array(z5.string()),
+  pending: z5.array(z5.string())
+});
+var versionTargetSchema = z5.object({
+  clientActionID: z5.uuid(),
+  itemID: itemIDSchema,
+  version: z5.int().positive()
+});
+var versionResultSchema = z5.object({ itemID: z5.string(), version: z5.int().positive() });
+var noticeEntrySchema = z5.object({
+  change: z5.enum(["created", "edited", "retired", "restored", "undone", "proposed"]),
+  isKept: z5.boolean(),
+  item: memoryItemSchema.extend({ change: z5.enum(["created", "edited", "retired", "restored", "undone"]) }).nullable(),
+  itemID: z5.string(),
+  proposalID: z5.string().nullable(),
+  sequence: z5.int().nonnegative(),
+  version: z5.int().positive().nullable()
+});
+var memoryNoticeSchema = z5.object({
+  entries: z5.array(noticeEntrySchema),
+  kind: z5.enum(["turn", "batch", "catch_up", "run"]),
+  messageSequence: z5.int().nonnegative().nullable(),
+  noticeKey: z5.string(),
+  proposed: z5.int().nonnegative(),
+  remembered: z5.int().nonnegative(),
+  retired: z5.int().nonnegative(),
+  sequence: z5.int().nonnegative()
+});
+var memoryViewContract = {
+  listItems: memoryView.errors({ INVALID_CURSOR: { message: "No page returned this cursor", status: 400 } }).input(z5.object({
+    after: z5.string().max(20).optional(),
+    kind: kindSchema.optional(),
+    limit: z5.int().min(1).max(100).optional(),
+    state: z5.enum(["active", "retired", "forgotten"])
+  })).output(z5.object({ items: z5.array(memoryItemSchema), next: z5.string().nullable() })),
+  findItems: memoryView.input(z5.object({ query: z5.string().min(1).max(500) })).output(z5.object({
+    items: z5.array(memoryMatchSchema),
+    searchMode: z5.enum(["hybrid", "keyword", "keyword-fallback"])
+  })),
+  readPinnedCore: memoryView.output(z5.object({
+    budget: z5.int().nonnegative(),
+    items: z5.array(memoryItemSchema),
+    tokens: z5.int().nonnegative()
+  })),
+  readItem: memoryView.errors({ MEMORY_ITEM_NOT_FOUND: { message: "No memory item has this ID", status: 404 } }).input(z5.object({ itemID: itemIDSchema })).output(memoryItemDetailSchema),
+  retire: memoryChange.input(versionTargetSchema).output(versionResultSchema),
+  restore: memoryChange.input(versionTargetSchema).output(versionResultSchema),
+  listNotices: memoryView.input(z5.object({ thread: z5.string().min(1).max(200) })).output(z5.object({ notices: z5.array(memoryNoticeSchema) })),
+  undo: memoryChange.errors({
+    PINNED_CORE_FULL: { message: "The undo takes the pinned core past its budget", status: 409 }
+  }).input(versionTargetSchema).output(versionResultSchema),
+  keep: memoryChange.input(versionTargetSchema).output(versionResultSchema),
+  previewForget: memoryView.errors({
+    MEMORY_ITEM_NOT_FOUND: { message: "No memory item has this ID", status: 404 },
+    STALE_VERSION: { message: "The memory item has moved past that version", status: 409 }
+  }).input(z5.object({ itemID: itemIDSchema, version: z5.int().positive() })).output(forgetPreviewSchema),
+  forget: memoryChange.input(versionTargetSchema).output(z5.object({ itemID: z5.string() })),
+  previewForgetRetired: memoryView.output(retiredForgetPreviewSchema),
+  forgetRetired: memoryChange.input(retiredForgetSchema).output(forgetStatusSchema),
+  readForgetStatus: memoryView.input(z5.object({ itemIDs: z5.array(itemIDSchema).min(1).max(100) })).output(forgetStatusSchema),
+  pin: memoryChange.errors({
+    PINNED_CORE_FULL: { message: "The pin takes the pinned core past its budget", status: 409 }
+  }).input(versionTargetSchema.extend({ isPinned: z5.boolean() })).output(z5.object({ isPinned: z5.boolean(), itemID: z5.string() })),
+  markSensitive: memoryChange.input(z5.object({ clientActionID: z5.uuid(), isSensitive: z5.boolean(), itemID: itemIDSchema })).output(z5.object({ isSensitive: z5.boolean(), itemID: z5.string() })),
+  listProposals: memoryView.output(z5.object({ proposals: z5.array(memoryProposalSchema) })),
+  approveProposals: memoryView.input(z5.object({
+    answers: z5.array(approvalAnswerSchema).min(1).max(50)
+  })).output(proposalOutcomesSchema),
+  rejectProposals: memoryView.input(z5.object({
+    answers: z5.array(rejectionAnswerSchema).min(1).max(50)
+  })).output(proposalOutcomesSchema),
+  ...memoryExportContract,
+  ...momentContract
+};
+
+// src/span-schema.ts
+import { z as z6 } from "zod";
+var spanSchema = z6.object({
+  end: z6.int().nonnegative(),
+  source: z6.enum(["typed", "pasted", "dropped", "unknown"]),
+  start: z6.int().nonnegative()
+});
+
+// src/task-schema.ts
+import { z as z7 } from "zod";
+var taskSchema = z7.object({
+  error: z7.string().optional(),
+  errorLimit: z7.int().positive().optional(),
+  errors: z7.int().positive().optional(),
+  retryAt: z7.date().optional(),
+  stepKey: z7.string().optional(),
+  taskID: z7.string()
+});
+
+// src/tool-call-schema.ts
+import { z as z8 } from "zod";
+var jsonObjectSchema = z8.record(z8.string(), z8.unknown());
+var toolCallSchema = z8.object({
+  callID: z8.string(),
+  content: jsonObjectSchema.optional(),
+  input: jsonObjectSchema.optional(),
+  outcome: z8.string().optional(),
+  tool: z8.string().optional()
+});
+
+// src/contract.ts
+var clientActionIDSchema = z9.uuid();
+var sequenceSchema = z9.int().nonnegative();
+var threadSchema = z9.string().min(1).max(200);
+var imageSchema = z9.object({ mediaType: z9.enum(imageLimits.mediaTypes) });
+var imageFilesSchema = z9.array(z9.file());
+var imageRefSchema = z9.object({
+  position: z9.int().nonnegative(),
+  sequence: sequenceSchema,
+  thread: threadSchema
+});
+var versionRefSchema = z9.object({
+  itemID: z9.string().min(1).max(200),
+  version: z9.int().nonnegative()
+});
+var recallItemSchema = versionRefSchema.extend({ score: z9.number().optional() });
+var recallSchema = z9.object({ items: z9.array(recallItemSchema) });
+var ratingItemSchema = versionRefSchema.extend({
+  hasNote: z9.boolean(),
+  verdict: z9.enum(["helpful", "noise", "misleading"])
+});
+var ratingSchema = z9.object({
+  items: z9.array(ratingItemSchema),
+  ratedBy: z9.string().optional(),
+  recalledSequence: sequenceSchema
+});
+var tokenCountSchema = z9.int().nonnegative();
+var contextSchema = z9.object({ size: tokenCountSchema, window: z9.int().positive() });
+var compactionSchema = z9.object({
+  postTokens: tokenCountSchema.optional(),
+  preTokens: tokenCountSchema,
+  trigger: z9.enum(["manual", "auto"])
+});
+var summarySchema = z9.object({
+  contextSize: tokenCountSchema.optional(),
+  summaryTokens: tokenCountSchema,
+  text: z9.string().optional(),
+  trigger: z9.enum(["threshold", "overflow"])
+});
+var compactionFailureSchema = z9.object({ failures: z9.int().positive() });
+var ratingNoteRefSchema = z9.object({
+  itemID: z9.string().min(1).max(200),
+  sequence: sequenceSchema
+});
+var ratingNoteSchema = ratingNoteRefSchema.extend({
+  status: z9.enum(["readable", "shredded", "unreadable", "missing"]),
+  text: z9.string().optional()
+});
+var versionTextSchema = versionRefSchema.extend({
+  status: z9.enum(["readable", "shredded", "unreadable", "missing"]),
+  text: z9.string().optional()
+});
+var recordSchema = z9.object({
+  compaction: compactionSchema.optional(),
+  compactionFailure: compactionFailureSchema.optional(),
+  forget: z9.object({ sequence: sequenceSchema }).optional(),
+  context: contextSchema.optional(),
+  kind: z9.string(),
+  message: z9.object({
+    clientMessageId: z9.uuid().optional(),
+    images: z9.array(imageSchema).optional(),
+    spans: z9.array(spanSchema).optional(),
+    text: z9.string()
+  }).optional(),
+  moment: z9.object({ momentID: z9.string(), shortID: z9.string(), title: z9.string().optional() }).optional(),
+  rating: ratingSchema.optional(),
+  recall: recallSchema.optional(),
+  recordedAt: z9.date(),
+  sequence: sequenceSchema,
+  summary: summarySchema.optional(),
+  thread: threadSchema,
+  task: taskSchema.optional(),
+  toolCall: toolCallSchema.optional()
+});
+var writerErrorSchema = z9.object({ at: z9.date(), code: z9.string(), message: z9.string().nullable() }).nullable();
+var sessionSchema = z9.object({
+  createdAt: z9.date(),
+  current: z9.boolean(),
+  deviceName: z9.string(),
+  lastUsedAt: z9.date(),
+  sessionID: z9.uuid()
+});
+var checkedAction = signedIn.errors(reusedIDErrors);
+var followRecords = signedIn.input(z9.object({ afterSequence: sequenceSchema, thread: threadSchema.optional() })).output(eventIterator2(z9.object({ record: recordSchema })));
+var contract = {
+  conversation: {
+    read: signedIn.errors({ THREAD_NOT_FOUND: { message: "No thread has this ID", status: 404 } }).input(z9.object({
+      beforeSequence: sequenceSchema.optional(),
+      limit: z9.int().min(1).max(200).optional(),
+      thread: threadSchema
+    })).output(z9.object({
+      hasEarlier: z9.boolean(),
+      readAtSequence: sequenceSchema,
+      records: z9.array(recordSchema),
+      lastStepEnd: recordSchema.nullable().optional()
+    })),
+    send: checkedAction.errors({
+      IMAGE_REFUSED: imageRefusedError,
+      THREAD_NOT_FOUND: { message: "No thread has this ID", status: 404 }
+    }).input(z9.object({
+      clientMessageId: clientActionIDSchema,
+      images: imageFilesSchema.optional(),
+      spans: z9.array(spanSchema).max(1e5),
+      text: z9.string().min(1).max(1e5),
+      thread: threadSchema,
+      timeZone: z9.string().min(1).max(100).optional(),
+      writtenAt: z9.iso.datetime().optional()
+    })).output(z9.object({ duplicate: z9.boolean(), sequence: sequenceSchema })),
+    readImage: signedIn.errors({ IMAGE_NOT_FOUND: imageNotFoundError }).input(imageRefSchema).output(z9.file()),
+    forget: checkedAction.errors({
+      RECORD_NOT_FOUND: {
+        message: "No message or reply on this thread has this sequence",
+        status: 404
+      }
+    }).input(z9.object({
+      clientActionID: clientActionIDSchema,
+      sequence: sequenceSchema,
+      thread: threadSchema
+    })).output(z9.object({ forgottenAt: z9.date() }))
+  },
+  memory: {
+    readVersions: signedIn.input(z9.object({ versions: z9.array(versionRefSchema).min(1).max(100) })).output(z9.object({ versions: z9.array(versionTextSchema) })),
+    readRatingNotes: signedIn.input(z9.object({ notes: z9.array(ratingNoteRefSchema).min(1).max(100) })).output(z9.object({ notes: z9.array(ratingNoteSchema) })),
+    writerStatus: signedIn.output(z9.object({
+      isEnabled: z9.boolean(),
+      backlog: z9.int().nonnegative(),
+      batches: z9.int().nonnegative(),
+      cursor: sequenceSchema,
+      failures: z9.int().nonnegative(),
+      isCatchingUp: z9.boolean(),
+      lastError: writerErrorSchema,
+      retryAt: z9.date().nullable()
+    })),
+    consolidatorStatus: signedIn.output(z9.object({ isEnabled: z9.boolean() })),
+    ...memoryViewContract
+  },
+  log: {
+    follow: followRecords.route({ deprecated: true })
+  },
+  records: {
+    follow: followRecords
+  },
+  sessions: {
+    enrol: oc2.errors(reusedIDErrors).errors({
+      ENROLMENT_CODE_INVALID: {
+        message: "The enrolment code is unknown, used or lapsed",
+        status: 400
+      }
+    }).input(z9.object({
+      clientActionID: clientActionIDSchema,
+      code: z9.string().min(1).max(100),
+      deviceName: z9.string().min(1).max(100),
+      tokenDelivery: z9.enum(["cookie", "bearer"])
+    })).output(z9.object({ sessionID: z9.uuid(), token: z9.string().optional() })),
+    issueCode: checkedAction.input(z9.object({ clientActionID: clientActionIDSchema })).output(z9.object({ code: z9.string(), expiresAt: z9.date() })),
+    list: signedIn.output(z9.object({ sessions: z9.array(sessionSchema) })),
+    revoke: checkedAction.errors({ SESSION_NOT_FOUND: { message: "No session has this ID", status: 404 } }).input(z9.object({ clientActionID: clientActionIDSchema, sessionID: z9.uuid() })).output(z9.object({ revokedAt: z9.date() }))
+  }
+};
+// src/host-contract.ts
+import { oc as oc3 } from "@orpc/contract";
+import { z as z10 } from "zod";
+var versionRefSchema2 = z10.object({ itemID: z10.string(), version: z10.int().positive() });
+var versionTargetSchema2 = z10.strictObject({
+  itemID: z10.string().min(1),
+  version: z10.int().positive()
+});
+var itemTextSchema2 = z10.string().max(2000).regex(/\S/u);
+var proposalOriginSchema2 = z10.enum(["owner", "conversation", "task", "memory_writer"]);
+var memoryOriginSchema = z10.enum([...proposalOriginSchema2.options, "lapse"]);
+var contentSourceSchema = z10.enum(["owner", "owner_data", "untrusted"]);
+var reviewReasonSchema2 = z10.enum([
+  "no_quote",
+  "quote_not_typed",
+  "quote_in_quoted_block",
+  "invisible_character",
+  "token_missing",
+  "checker_not_asserted",
+  "checker_unsure",
+  "checker_unreachable",
+  "forgotten_evidence",
+  "ambiguous_target",
+  "pinned",
+  "other",
+  "self_note",
+  "from_photo",
+  "sensitive"
+]);
+var proposalSourceSchema2 = z10.object({
+  origin: proposalOriginSchema2,
+  thread: z10.string().nullable(),
+  proposedAt: z10.date()
+});
+var pendingProposalSchema = z10.object({
+  proposalID: z10.string(),
+  operation: z10.enum(["remember", "retire", "pin"]),
+  itemID: z10.string(),
+  targetVersion: z10.int().nullable(),
+  isPinned: z10.boolean(),
+  subject: z10.enum(["owner", "self", "shared"]),
+  isSensitive: z10.boolean(),
+  kind: z10.enum(["fact", "self"]),
+  reason: reviewReasonSchema2,
+  actionHash: z10.string(),
+  origin: proposalOriginSchema2,
+  source: contentSourceSchema,
+  createdAt: z10.date(),
+  lapseAt: z10.date(),
+  sources: z10.array(proposalSourceSchema2),
+  text: z10.string(),
+  quote: z10.string().nullable()
+});
+var closeMatchSchema2 = z10.object({ itemID: z10.string(), version: z10.int(), text: z10.string() });
+var approvalResultSchema = z10.discriminatedUnion("status", [
+  z10.object({ status: z10.literal("applied"), itemID: z10.string(), version: z10.int() }),
+  z10.object({ status: z10.literal("close_match"), item: closeMatchSchema2 })
+]);
+var historyVersionSchema = z10.object({
+  version: z10.int(),
+  change: z10.enum(["created", "edited", "retired", "restored", "undone"]),
+  state: z10.enum(["active", "retired"]),
+  origin: memoryOriginSchema,
+  source: contentSourceSchema,
+  recordedAt: z10.date(),
+  status: z10.enum(["readable", "shredded", "unreadable"]),
+  text: z10.string().nullable()
+});
+var itemHistorySchema = z10.object({
+  itemID: z10.string(),
+  subject: z10.enum(["owner", "self", "shared"]),
+  kind: z10.enum(["fact", "self"]),
+  state: z10.enum(["active", "retired", "forgetting", "forgotten"]),
+  versions: z10.array(historyVersionSchema)
+});
+var changeInputSchema = z10.object({
+  itemID: z10.string(),
+  version: z10.int(),
+  text: z10.string().nullable(),
+  isCurrent: z10.boolean()
+});
+var changeCommentSchema = z10.object({ text: z10.string(), at: z10.date() });
+var consolidationChangeSchema = z10.object({
+  changeID: z10.string(),
+  shortID: z10.string(),
+  kind: z10.enum(["merge", "rewrite", "retire"]),
+  inputs: z10.array(changeInputSchema),
+  text: z10.string().nullable(),
+  reason: z10.string(),
+  source: contentSourceSchema,
+  actionHash: z10.string(),
+  lapseAt: z10.date(),
+  comment: changeCommentSchema.nullable()
+});
+var consolidationDiffSchema = z10.object({
+  diffID: z10.string(),
+  model: z10.string().nullable(),
+  createdAt: z10.date(),
+  changes: z10.array(consolidationChangeSchema),
+  summary: z10.string().nullable()
+});
+var changeOutcomeSchema = z10.discriminatedUnion("status", [
+  z10.object({
+    changeID: z10.string(),
+    status: z10.literal("applied"),
+    versions: z10.array(versionRefSchema2)
+  }),
+  z10.object({ changeID: z10.string(), status: z10.literal("refused"), code: z10.string() })
+]);
+var changeAnswerSchema = z10.strictObject({
+  changeID: z10.string().min(1),
+  actionHash: z10.string().min(1)
+});
+var proposalAnswerSchema2 = z10.strictObject({
+  proposalID: z10.string().min(1),
+  actionHash: z10.string().min(1)
+});
+var hostSessionSchema = z10.object({
+  sessionID: z10.string(),
+  deviceName: z10.string(),
+  createdAt: z10.date(),
+  lastUsedAt: z10.date()
+});
+var subjectCountSchema = z10.object({
+  owner: z10.int().nonnegative(),
+  shared: z10.int().nonnegative(),
+  self: z10.int().nonnegative()
+});
+var memory = oc3.errors({
+  MEMORY_NOT_STARTED: { message: "the memory store has not started yet", status: 503 },
+  NOT_FOUND: { message: "nothing has that ID", status: 404 },
+  PROPOSAL_HASH: { message: "the action hash names another proposal", status: 409 },
+  PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
+  STALE_VERSION: { message: "the item has moved past that version", status: 409 },
+  WRONG_STATE: { message: "the item is not in a state that change takes", status: 409 },
+  PINNED_CORE_FULL: { message: "the pinned core is full", status: 409 },
+  REVISION_TARGET: { message: "that item cannot take the revision", status: 400 },
+  RETIREMENT_EDIT: { message: "a retirement takes no edited text", status: 400 },
+  PIN_EDIT: { message: "a pin takes no edited text", status: 400 },
+  SELF_NOTE_REFUSED: { message: "a self-note never takes that change", status: 409 }
+});
+var skillFileSchema = z10.object({ path: z10.string(), text: z10.string() });
+var pendingSkillProposalSchema = z10.object({
+  proposalID: z10.string(),
+  name: z10.string(),
+  skillHash: z10.string(),
+  baseHash: z10.string().nullable(),
+  files: z10.array(skillFileSchema),
+  inForce: z10.object({
+    skillHash: z10.string(),
+    origin: z10.enum(["definitions", "vendored", "nixie"]),
+    files: z10.array(skillFileSchema)
+  }).nullable(),
+  untypedToken: z10.object({ kind: z10.string(), raw: z10.string() }).nullable(),
+  thread: z10.string().nullable(),
+  provenance: z10.object({ runID: z10.string(), callID: z10.string(), profile: z10.string() }),
+  createdAt: z10.date(),
+  lapseAt: z10.date(),
+  isStale: z10.boolean()
+});
+var skillAnswerSchema = z10.strictObject({
+  proposalID: z10.string().min(1),
+  skillHash: z10.string().min(1)
+});
+var skills = oc3.errors({
+  NOT_FOUND: { message: "nothing has that ID", status: 404 },
+  PROPOSAL_HASH: { message: "the skill hash names other files", status: 409 },
+  PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
+  STALE_BASE: { message: "the skill in force moved past the proposal", status: 409 },
+  SKILL_CHECK: { message: "the files fail the seed checks", status: 400 },
+  WRONG_STATE: { message: "the skill nixie wrote is no longer in force", status: 409 }
+});
+var definitionsSkillSchema = z10.object({ skillHash: z10.string(), origin: z10.enum(["definitions", "vendored"]) }).nullable();
+var writtenSkillSchema = z10.object({
+  approvalID: z10.string(),
+  proposalID: z10.string(),
+  name: z10.string(),
+  skillHash: z10.string(),
+  base: definitionsSkillSchema,
+  definitions: definitionsSkillSchema,
+  isConflict: z10.boolean(),
+  pullRequestURL: z10.url().nullable(),
+  approvedAt: z10.date()
+});
+var promptPartFileSchema = z10.object({ path: z10.string(), text: z10.string() });
+var promptEntrySchema = z10.record(z10.string(), z10.string());
+var pendingPromptProposalSchema = z10.object({
+  proposalID: z10.string(),
+  promptID: z10.string(),
+  proposalHash: z10.string(),
+  baseHash: z10.string().nullable(),
+  entry: promptEntrySchema,
+  files: z10.array(promptPartFileSchema),
+  reason: z10.string(),
+  inForce: z10.object({ parts: promptEntrySchema, template: z10.string().nullable() }).nullable(),
+  thread: z10.string().nullable(),
+  provenance: z10.object({ runID: z10.string(), callID: z10.string(), profile: z10.string() }),
+  createdAt: z10.date(),
+  lapseAt: z10.date(),
+  isStale: z10.boolean()
+});
+var promptAnswerSchema = z10.strictObject({
+  proposalID: z10.string().min(1),
+  proposalHash: z10.string().min(1)
+});
+var prompts = oc3.errors({
+  NOT_FOUND: { message: "nothing has that ID", status: 404 },
+  PROPOSAL_HASH: { message: "the proposal hash names another override", status: 409 },
+  PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
+  STALE_BASE: { message: "the override in force moved past the proposal", status: 409 },
+  PROMPT_CHECK: { message: "the override fails the definitions checks", status: 400 }
+});
+var forgottenItemsSchema = z10.object({ itemIDs: z10.array(z10.string()) });
+var hostContract = {
+  reset: oc3.output(z10.object({
+    resetAt: z10.date(),
+    lastSequence: z10.int().nonnegative(),
+    keptSessions: z10.int().nonnegative()
+  })),
+  resetConversations: oc3.output(z10.object({
+    resetAt: z10.date(),
+    lastSequence: z10.int().nonnegative(),
+    shreddedRecords: z10.int().nonnegative()
+  })),
+  sessions: {
+    issueCode: oc3.output(z10.object({ code: z10.string(), expiresAt: z10.date() })),
+    list: oc3.output(z10.array(hostSessionSchema)),
+    label: oc3.errors({
+      SESSION_NOT_FOUND: {
+        message: "no device session that is still signed in has that ID",
+        status: 404
+      },
+      LABEL_INVALID: { message: "a label holds 1 to 100 characters besides spaces", status: 400 }
+    }).input(z10.strictObject({ sessionID: z10.string().min(1), label: z10.string() })).output(z10.object({ sessionID: z10.string(), label: z10.string() }))
+  },
+  memory: {
+    proposals: {
+      list: memory.output(z10.array(pendingProposalSchema)),
+      approve: memory.input(proposalAnswerSchema2.extend({
+        revisionOf: versionTargetSchema2.optional(),
+        ignoreCloseMatch: z10.boolean().optional(),
+        editedText: itemTextSchema2.optional()
+      })).output(approvalResultSchema),
+      reject: memory.input(proposalAnswerSchema2.extend({ reason: z10.string().max(500).regex(/\S/u).optional() })).output(z10.object({ proposalID: z10.string() }))
+    },
+    subjects: memory.output(z10.object({ items: subjectCountSchema, proposals: subjectCountSchema })),
+    items: {
+      read: memory.input(z10.strictObject({ itemID: z10.string().min(1) })).output(itemHistorySchema),
+      edit: memory.input(versionTargetSchema2.extend({ text: itemTextSchema2 })).output(versionRefSchema2),
+      retire: memory.input(versionTargetSchema2).output(versionRefSchema2),
+      restore: memory.input(versionTargetSchema2).output(versionRefSchema2),
+      forget: memory.input(versionTargetSchema2).output(z10.object({ itemID: z10.string() })),
+      forgetAll: memory.output(forgottenItemsSchema),
+      pin: memory.input(z10.strictObject({ itemID: z10.string().min(1), isPinned: z10.boolean() })).output(z10.object({ itemID: z10.string(), isPinned: z10.boolean() }))
+    },
+    consolidation: {
+      read: memory.output(consolidationDiffSchema.nullable()),
+      approve: memory.input(z10.strictObject({ answers: z10.array(changeAnswerSchema).min(1).max(30) })).output(z10.object({ outcomes: z10.array(changeOutcomeSchema) })),
+      reject: memory.input(changeAnswerSchema).output(z10.object({ changeID: z10.string() }))
+    }
+  },
+  skills: {
+    proposals: {
+      list: skills.output(z10.array(pendingSkillProposalSchema)),
+      approve: skills.input(skillAnswerSchema.extend({ files: z10.array(skillFileSchema).min(1).optional() })).output(z10.object({ proposalID: z10.string(), approvalID: z10.string(), skillHash: z10.string() })),
+      reject: skills.input(skillAnswerSchema.extend({ reason: z10.string().max(500).regex(/\S/u) })).output(z10.object({ proposalID: z10.string() }))
+    },
+    written: {
+      list: skills.output(z10.array(writtenSkillSchema)),
+      resolve: skills.input(z10.strictObject({
+        approvalID: z10.string().min(1),
+        keep: z10.enum(["nixie", "definitions"])
+      })).output(z10.object({ approvalID: z10.string(), keep: z10.enum(["nixie", "definitions"]) }))
+    }
+  },
+  prompts: {
+    proposals: {
+      list: prompts.output(z10.array(pendingPromptProposalSchema)),
+      approve: prompts.input(promptAnswerSchema.extend({
+        entry: promptEntrySchema.optional(),
+        files: z10.array(promptPartFileSchema).optional()
+      })).output(z10.object({ proposalID: z10.string(), approvalID: z10.string(), proposalHash: z10.string() })),
+      reject: prompts.input(promptAnswerSchema.extend({ reason: z10.string().max(500).regex(/\S/u) })).output(z10.object({ proposalID: z10.string() }))
+    }
+  }
+};
+// src/is-time-zone.ts
+function isTimeZone(zone) {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: zone }).resolvedOptions().timeZone !== "";
+  } catch {
+    return false;
+  }
+}
+// src/session-cookie-name.ts
+var sessionCookieName = "nixie_session";
+
+// src/render-session-cookie.ts
+var MAX_AGE_S = 400 * 24 * 60 * 60;
+function renderSessionCookie(token) {
+  const maxAgeS = token === null ? 0 : MAX_AGE_S;
+  return `${sessionCookieName}=${token ?? ""}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=${maxAgeS}`;
+}
+export {
+  buildPendingInput,
+  buildQueryUtils,
+  buildSpanState,
+  clientHeaderName,
+  contract,
+  hostContract,
+  imageLimits,
+  isTimeZone,
+  pickSpanSource,
+  proposalOutcomeSchema,
+  renderSessionCookie,
+  sessionCookieName,
+  spanSchema
+};