@cueframe/kernel 0.0.1

package/dist/chunk-6EQXLEP6.js

@@ -0,0 +1,194 @@
+import {
+  EntityId,
+  ISODateTime,
+  NonEmptyString
+} from "./chunk-XELS2BGA.js";
+
+// ../data-models/account-model/src/validators/userSettings.ts
+import { z } from "zod";
+var UserSettings = z.object({
+  id: EntityId("userSettings"),
+  userId: NonEmptyString,
+  enableUnderstanding: z.boolean().optional(),
+  activeBrandKitId: EntityId("brandKits").optional()
+});
+
+// ../data-models/account-model/src/validators/conversation.ts
+import { z as z2 } from "zod";
+var ConversationProject = z2.object({
+  id: NonEmptyString,
+  home: z2.enum(["local", "cloud"])
+});
+var Conversation = z2.object({
+  id: EntityId("conversations"),
+  /**
+   * THE THREAD'S IDENTITY, and the app is the one that mints it.
+   *
+   * A conversation exists in the client before any store has seen it: the
+   * Director opens a chat, the user types, and only when the turn ends does a
+   * row get written. So the id that names a thread has to be one the client
+   * chose (`conv_<nanoid>`), not one a store assigns — otherwise the first
+   * save is an INSERT under a name the client cannot predict, the client keeps
+   * using its own name, and every subsequent save inserts again. That is
+   * exactly what web did until 2026-08-17: an N-turn conversation became N
+   * rows, and Delete silently deleted nothing because the id the user's
+   * sidebar held had never named a document.
+   *
+   * The desktop always had this right — sqlite is an `INSERT OR REPLACE` keyed
+   * on the client id. This field makes the org's store agree, via a unique
+   * lookup on `by_userId_clientId`: writes are an upsert on the id the app
+   * chose, and Convex's `_id` goes back to being an internal detail nobody
+   * outside this table ever sees or stores.
+   */
+  clientId: NonEmptyString,
+  userId: NonEmptyString,
+  title: NonEmptyString,
+  /**
+   * The project whose media, timeline and history this thread's turns are
+   * about. ABSENT is a meaning — a workspace thread, started on a surface with
+   * no project open — not a missing value: such a thread belongs to the user's
+   * workspace and survives every project switch precisely because it names no
+   * project. It is `optional` rather than nullable because rows written before
+   * the field existed have no project recorded, and nothing may invent one for
+   * them.
+   */
+  project: ConversationProject.optional(),
+  /**
+   * When the thread was STARTED — supplied by the app, kept by the store.
+   *
+   * Stored rather than read off Convex's `_creationTime`, which is when the
+   * DOCUMENT was inserted and not when the conversation began. Those are the
+   * same moment for a thread born in the cloud and very different for one that
+   * arrives there later: moving a project to the cloud re-homes its threads
+   * (`adoptIntoProject`), and a months-old conversation would have shown up
+   * dated today. The desktop has always stored the app's value; this is the
+   * org's store agreeing, and it is what lets the same thread report the same
+   * age on both sides of a move.
+   *
+   * Immutable after the first write on both stores — a thread's age is a fact
+   * about the thread, not about its most recent turn.
+   */
+  createdAt: ISODateTime,
+  /**
+   * When the thread last had a turn — the key the history list sorts on.
+   *
+   * Stored rather than derived because the two things a store can offer for
+   * free are both wrong: Convex's `_creationTime` is when the thread STARTED
+   * (so a months-old thread the user just added a turn to sorts to the bottom,
+   * which is the opposite of what a history list is for), and a patch does not
+   * move it. The desktop has ordered by `updated_at DESC` since migration 015;
+   * this is the org's store agreeing.
+   */
+  updatedAt: ISODateTime,
+  /** JSON-encoded array of UI messages (role + content). */
+  messages: z2.string()
+});
+
+// ../data-models/account-model/src/validators/uploadToken.ts
+import { z as z3 } from "zod";
+var UploadTokenScope = z3.enum(["tus", "companion"]);
+var UploadToken = z3.object({
+  id: EntityId("uploadTokens"),
+  token: NonEmptyString,
+  userId: NonEmptyString,
+  projectId: EntityId("projects").optional(),
+  orgId: NonEmptyString.optional(),
+  scope: UploadTokenScope.optional(),
+  expiresAt: ISODateTime
+});
+
+// ../data-models/account-model/src/validators/contextFile.ts
+import { z as z4 } from "zod";
+var ContextFile = z4.object({
+  id: EntityId("contextFiles"),
+  orgId: NonEmptyString,
+  userId: NonEmptyString,
+  filename: NonEmptyString,
+  content: z4.string(),
+  generatedFrom: z4.array(NonEmptyString),
+  version: z4.number().int().nonnegative(),
+  updatedAt: ISODateTime
+});
+
+// ../data-models/account-model/src/validators/dashboardInsight.ts
+import { z as z5 } from "zod";
+var DashboardInsight = z5.object({
+  id: EntityId("dashboardInsights"),
+  orgId: NonEmptyString,
+  /** Hash of the input set that produced this snapshot (cache key). */
+  sourceHash: NonEmptyString,
+  heroInsight: NonEmptyString,
+  contentSuggestions: z5.array(NonEmptyString),
+  generatedAt: ISODateTime
+});
+
+// ../data-models/account-model/src/validators/sessionToken.ts
+import { z as z6 } from "zod";
+var SessionTokenScope = z6.enum(["session-read"]);
+var SessionToken = z6.object({
+  id: EntityId("sessionTokens"),
+  token: NonEmptyString,
+  sessionId: NonEmptyString,
+  projectId: EntityId("projects"),
+  orgId: NonEmptyString,
+  scope: SessionTokenScope,
+  expiresAt: ISODateTime,
+  // ── Session-state (the token row IS the session row; cleanup-dominant) ──
+  /** The warm sandbox this session is bound to, set once it's created. The
+   *  session reconnects by this id (provider.get) per render — the platform-native
+   *  persistent-resource pattern. */
+  sandboxId: NonEmptyString.optional(),
+  /** Epoch-ms when the warm box became ready (stamped alongside `sandboxId`). The
+   *  billable-uptime clock start — `closeSession` bills `compose_session_minutes`
+   *  from here. Absent = the box never booted, so nothing to bill. Stored as a raw
+   *  number (epoch-ms) like `expiresAt`, for cheap arithmetic. */
+  readyAt: z6.number().optional(),
+  /** The `_scheduled_functions` id of the pending durable auto-close
+   *  (`ctx.scheduler.runAfter`). Cancelled + rescheduled on activity (keep-alive),
+   *  fired on idle to reap the sandbox — crash-proof cleanup, not durability. */
+  scheduledCloseId: NonEmptyString.optional(),
+  /** The session-scoped SCRATCH composition (a derived sibling of the project's
+   *  active composition). Author-ops during the session mutate THIS row, never
+   *  active; `promoteScratch` commits it and `closeSession` discards it. Absent
+   *  until the session derives one (or the project had no active to derive from). */
+  scratchCompositionId: EntityId("compositions").optional(),
+  /** SERVER-owned evidence box (the sessionless score/preview ops). Managed
+   *  sessions bill per-op only (uptime metering skips them — flat per-op is the
+   *  public contract), run a SHORT idle TTL, never mint a scratch composition,
+   *  and are the only rows the managed resolver may reuse or evict. */
+  managed: z6.boolean().optional(),
+  /** Async-evidence lease: the jobId currently staging/judging on this box. A
+   *  second evidence op on the same box while the lease is live gets 409
+   *  box_busy instead of silently bumping the working-composition version out
+   *  from under the in-flight judge. Cleared at the job terminal; expiry is the
+   *  crash backstop. */
+  leaseJobId: NonEmptyString.optional(),
+  leaseExpiresAt: z6.number().optional()
+});
+
+// ../data-models/account-model/src/validators/workingComposition.ts
+import { z as z7 } from "zod";
+var WorkingComposition = z7.object({
+  id: EntityId("workingCompositions"),
+  sessionId: NonEmptyString,
+  projectId: EntityId("projects"),
+  orgId: NonEmptyString,
+  // Wire composition stored loose (mirrors compositionRuns.composition v.any()).
+  composition: z7.unknown(),
+  // Monotonic per-session edit counter — the read-your-writes handshake key.
+  version: z7.number(),
+  updatedAt: z7.number()
+});
+
+export {
+  UserSettings,
+  ConversationProject,
+  Conversation,
+  UploadTokenScope,
+  UploadToken,
+  ContextFile,
+  DashboardInsight,
+  SessionTokenScope,
+  SessionToken,
+  WorkingComposition
+};