artifact-cafe 0.0.15 → 0.0.17

package/dist/index.js

@@ -7,24 +7,17 @@ import { defineCommand, runMain, showUsage } from "citty";
 var AMBER = "\x1B[38;2;214;138;57m";
 var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
-var MUG = [
-  "        \u2596",
-  "      \u2598   \u259D",
-  "   \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E",
-  "   \u2502        \u251C\u2500\u256E",
-  "   \u2502        \u2502 \u2502",
-  "   \u2502        \u251C\u2500\u256F",
-  "   \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F",
-  "    \u203E\u203E\u203E\u203E\u203E\u203E\u203E\u203E"
-];
+var TICK_TOP = "   \u250C       \u2510";
+var GLYPH = "       \xE3";
+var TICK_BOTTOM = "   \u2514       \u2518";
 var WORDMARK = "   artifact.cafe";
 function printBanner() {
   const color = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
   const paint = (line, codes) => color ? `${codes}${line}${RESET}` : line;
   console.log();
-  for (const line of MUG) {
-    console.log(paint(line, AMBER));
-  }
+  console.log(paint(TICK_TOP, AMBER));
+  console.log(paint(GLYPH, BOLD));
+  console.log(paint(TICK_BOTTOM, AMBER));
   console.log();
   console.log(paint(WORDMARK, AMBER + BOLD));
   console.log();
@@ -69,8 +62,10 @@ var meResponseSchema = z.object({
   userId: z.string()
 });
 var artifactListItemSchema = z.object({
+  autoDeleteAt: z.string().datetime().nullable().optional(),
   createdAt: z.string(),
   currentVersionNumber: z.number().int().positive().nullable(),
+  expiresAt: z.string().datetime().nullable().optional(),
   id: z.string(),
   openCommentCount: z.number().int().nonnegative(),
   slug: z.string(),
@@ -181,7 +176,7 @@ var workspaceAvatarResponseSchema = z3.object({
 });
 
 // ../shared/src/comments.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../shared/src/emoji.ts
 import { z as z4 } from "zod";
@@ -193,15 +188,38 @@ function canonicalizeEmoji(s) {
 var iconEmojiSchema = z4.string().max(64).transform(canonicalizeEmoji).refine((s) => SINGLE_EMOJI.test(s), { message: "Must be a single emoji." }).nullable().describe("A single emoji shown as the icon, or null for the default.");
 
 // ../shared/src/publish.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
-// ../shared/src/review-mode.ts
+// ../shared/src/expiration.ts
 import { z as z5 } from "zod";
-var reviewModeSchema = z5.enum(["open", "readonly", "off"]);
-var setReviewModeSchema = z5.object({
+var MAX_EXPIRATION_SECONDS = 2147483647;
+var expirationSecondsSchema = z5.number().int().positive().max(MAX_EXPIRATION_SECONDS);
+var setExpirationSchema = z5.object({
+  expiresInSeconds: expirationSecondsSchema.nullable()
+});
+var expirationResponseSchema = z5.object({
+  autoDeleteAt: z5.string().datetime().nullable(),
+  expiresAt: z5.string().datetime().nullable()
+});
+function parseArtifactDuration(value) {
+  const match = /^([1-9]\d*)([mhd])$/.exec(value);
+  const units = { d: 86400, h: 3600, m: 60 };
+  const seconds = match ? Number(match[1]) * (units[match[2]] ?? 0) : 0;
+  if (!expirationSecondsSchema.safeParse(seconds).success) {
+    throw new Error(
+      `Duration must be a positive whole number followed by m, h, or d (for example 30m, 1h, 7d), up to ${MAX_EXPIRATION_SECONDS} seconds.`
+    );
+  }
+  return seconds;
+}
+
+// ../shared/src/review-mode.ts
+import { z as z6 } from "zod";
+var reviewModeSchema = z6.enum(["open", "readonly", "off"]);
+var setReviewModeSchema = z6.object({
   mode: reviewModeSchema
 });
-var reviewModeResponseSchema = z5.object({
+var reviewModeResponseSchema = z6.object({
   mode: reviewModeSchema
 });
 
@@ -220,274 +238,300 @@ function isSafeArtifactPath(p) {
 }
 var CARD_DESCRIPTION_MAX = 300;
 var CARD_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
-var manifestFileSchema = z6.object({
-  hash: z6.string().regex(/^sha256_[a-f0-9]{64}$/),
-  mimeType: z6.string().regex(/^[-\w.+]+\/[-\w.+]+$/, { message: "invalid MIME type" }),
-  path: z6.string().min(1).max(1024).refine(isSafeArtifactPath, {
+var manifestFileSchema = z7.object({
+  hash: z7.string().regex(/^sha256_[a-f0-9]{64}$/),
+  mimeType: z7.string().regex(/^[-\w.+]+\/[-\w.+]+$/, { message: "invalid MIME type" }),
+  path: z7.string().min(1).max(1024).refine(isSafeArtifactPath, {
     message: "path must be a safe relative path"
   }),
-  size: z6.number().int().positive()
+  size: z7.number().int().positive()
 });
-var publishSourceSchema = z6.object({
-  agent: z6.string().optional(),
-  runId: z6.string().optional(),
-  type: z6.literal("cli")
+var publishSourceSchema = z7.object({
+  agent: z7.string().optional(),
+  runId: z7.string().optional(),
+  type: z7.literal("cli")
 });
-var createPublishSessionSchema = z6.object({
-  artifactId: z6.string().nullable(),
+var createPublishSessionSchema = z7.object({
+  artifactId: z7.string().nullable(),
   // One-line share-card summary (`--description`). Overrides whatever the
   // entry HTML declares; leave it off and the API reads the document's own
   // `og:description`/`description` at finalize.
-  description: z6.string().max(CARD_DESCRIPTION_MAX).optional(),
-  entryPath: z6.string().optional(),
-  files: z6.array(manifestFileSchema).min(1).max(1e3),
+  description: z7.string().max(CARD_DESCRIPTION_MAX).optional(),
+  entryPath: z7.string().optional(),
+  expiresInSeconds: expirationSecondsSchema.optional(),
+  files: z7.array(manifestFileSchema).min(1).max(1e3),
   // SPEC-2 §6.4 — workspace placement is available only to authenticated
   // members; the API enforces membership and folder ownership. folderId
   // without workspaceId resolves against the account's personal workspace.
-  folderId: z6.string().min(1).optional(),
+  folderId: z7.string().min(1).optional(),
   // Bullet-point changelog for this version, authored by the publisher.
   // Optional on every publish (incl. v1); stored immutably on the version.
-  notes: z6.string().max(4e3).optional(),
+  notes: z7.string().max(4e3).optional(),
   source: publishSourceSchema,
-  title: z6.string().max(200).optional(),
-  workspaceId: z6.string().min(1).optional()
-});
-var publishSessionResponseSchema = z6.object({
-  artifactId: z6.string(),
-  expiresAt: z6.string(),
-  filesToUpload: z6.array(
-    z6.object({
-      method: z6.literal("PUT"),
-      path: z6.string(),
-      uploadUrl: z6.string().url()
+  title: z7.string().max(200).optional(),
+  workspaceId: z7.string().min(1).optional()
+});
+var publishSessionResponseSchema = z7.object({
+  artifactId: z7.string(),
+  expiresAt: z7.string(),
+  expiresInSeconds: expirationSecondsSchema.nullable().optional(),
+  filesToUpload: z7.array(
+    z7.object({
+      method: z7.literal("PUT"),
+      path: z7.string(),
+      uploadUrl: z7.string().url()
     })
   ),
-  publishSessionId: z6.string(),
-  skippedFiles: z6.array(z6.string()),
-  versionId: z6.string()
+  publishSessionId: z7.string(),
+  skippedFiles: z7.array(z7.string()),
+  versionId: z7.string()
 });
-var finalizeResponseSchema = z6.object({
-  artifactId: z6.string(),
+var finalizeResponseSchema = z7.object({
+  artifactId: z7.string(),
+  autoDeleteAt: z7.string().datetime().nullable().optional(),
   // API-key publishes create the artifact already claimed (SPEC §5.4) —
   // the CLI uses this to tell "claim URL pending" from "already yours".
-  claimed: z6.boolean(),
+  claimed: z7.boolean(),
   // Returned only on first publish of a new artifact (one-time).
-  claimUrl: z6.string().url().optional(),
-  publishToken: z6.string().optional(),
-  url: z6.string().url(),
-  versionId: z6.string(),
-  versionNumber: z6.number().int().positive(),
+  claimUrl: z7.string().url().optional(),
+  expiresAt: z7.string().datetime().nullable().optional(),
+  publishToken: z7.string().optional(),
+  url: z7.string().url(),
+  versionId: z7.string(),
+  versionNumber: z7.number().int().positive(),
   // SPEC-2 §5.2 — who can open the review URL. A publish into a folder
   // inherits that folder's visibility, so this is the only place the CLI
   // learns that a link it just printed is members-only. Optional so a new
   // CLI against an older API degrades to "unknown" instead of failing the
   // publish over a field that only shapes the closing message.
-  visibility: z6.enum(["public", "unlisted", "workspace", "private"]).optional(),
-  workspaceId: z6.string().nullable().optional()
-});
-var artifactResponseSchema = z6.object({
-  claimed: z6.boolean(),
-  currentVersion: z6.object({
-    entryUrl: z6.string().url(),
-    id: z6.string(),
-    versionNumber: z6.number().int().positive()
+  visibility: z7.enum(["public", "unlisted", "workspace", "private"]).optional(),
+  workspaceId: z7.string().nullable().optional()
+});
+var artifactResponseSchema = z7.object({
+  autoDeleteAt: z7.string().datetime().nullable().optional(),
+  claimed: z7.boolean(),
+  currentVersion: z7.object({
+    entryUrl: z7.string().url(),
+    id: z7.string(),
+    versionNumber: z7.number().int().positive()
   }).nullable(),
   // Custom icon, or null to render the default document glyph.
-  emoji: z6.string().nullable(),
+  emoji: z7.string().nullable(),
+  expiresAt: z7.string().datetime().nullable().optional(),
   // SPEC-2 §6.4 — placement + visibility surface on the artifact.
-  folderId: z6.string().nullable(),
-  id: z6.string(),
+  folderId: z7.string().nullable(),
+  id: z7.string(),
   // SPEC-2 §5.8 — what a viewer may do once in (open / readonly / off).
   reviewMode: reviewModeSchema,
-  slug: z6.string(),
-  title: z6.string(),
-  visibility: z6.enum(["public", "unlisted", "workspace", "private"]),
-  workspaceId: z6.string().nullable()
+  slug: z7.string(),
+  title: z7.string(),
+  visibility: z7.enum(["public", "unlisted", "workspace", "private"]),
+  workspaceId: z7.string().nullable()
 });
+function resolvePublishEntry(files, explicit) {
+  if (explicit !== void 0) {
+    if (!files.some((file) => file.path === explicit)) {
+      throw new Error(`Entry file "${explicit}" is not in the manifest.`);
+    }
+    return explicit;
+  }
+  const htmlFiles = files.filter(
+    (file) => file.mimeType === "text/html" && !file.path.includes("/")
+  );
+  if (htmlFiles.some((file) => file.path === "index.html")) {
+    return "index.html";
+  }
+  if (htmlFiles.length > 1) {
+    throw new Error(
+      `Multiple HTML files found (${htmlFiles.map((file) => file.path).join(", ")}). Specify an entry file.`
+    );
+  }
+  return htmlFiles[0]?.path;
+}
 
 // ../shared/src/comments.ts
-var anchorPageSchema = z7.string().max(1024).refine(isSafeArtifactPath, {
+var anchorPageSchema = z8.string().max(1024).refine(isSafeArtifactPath, {
   message: "page must be a safe relative path"
 }).optional();
-var elementSnapshotSchema = z7.object({
-  classes: z7.string().max(256).optional(),
-  id: z7.string().max(256).optional(),
-  tag: z7.string().min(1).max(128),
-  text: z7.string().max(200).optional()
+var elementSnapshotSchema = z8.object({
+  classes: z8.string().max(256).optional(),
+  id: z8.string().max(256).optional(),
+  tag: z8.string().min(1).max(128),
+  text: z8.string().max(200).optional()
 });
-var pointAnchorSchema = z7.object({
+var pointAnchorSchema = z8.object({
   element: elementSnapshotSchema.optional(),
   // elementPath is the primary anchor; x/y are offsets within the
   // element's box, normalized 0..1 (SPEC.md §8.1).
-  elementPath: z7.string().max(2048),
+  elementPath: z8.string().max(2048),
   page: anchorPageSchema,
-  type: z7.literal("point"),
-  viewportHeight: z7.number().int().positive().max(1e5),
-  viewportWidth: z7.number().int().positive().max(1e5),
-  x: z7.number().min(0).max(1),
-  y: z7.number().min(0).max(1)
-});
-var textAnchorSchema = z7.object({
-  elementPath: z7.string().max(2048),
-  endOffset: z7.number().int().nonnegative().max(1e8),
+  type: z8.literal("point"),
+  viewportHeight: z8.number().int().positive().max(1e5),
+  viewportWidth: z8.number().int().positive().max(1e5),
+  x: z8.number().min(0).max(1),
+  y: z8.number().min(0).max(1)
+});
+var textAnchorSchema = z8.object({
+  elementPath: z8.string().max(2048),
+  endOffset: z8.number().int().nonnegative().max(1e8),
   page: anchorPageSchema,
-  prefix: z7.string().max(200).optional(),
-  quote: z7.string().min(1).max(1e3),
-  startOffset: z7.number().int().nonnegative().max(1e8),
-  suffix: z7.string().max(200).optional(),
-  type: z7.literal("text")
+  prefix: z8.string().max(200).optional(),
+  quote: z8.string().min(1).max(1e3),
+  startOffset: z8.number().int().nonnegative().max(1e8),
+  suffix: z8.string().max(200).optional(),
+  type: z8.literal("text")
 });
-var pageAnchorSchema = z7.object({
+var pageAnchorSchema = z8.object({
   page: anchorPageSchema,
-  type: z7.literal("page")
+  type: z8.literal("page")
 });
-var anchorSchema = z7.discriminatedUnion("type", [
+var anchorSchema = z8.discriminatedUnion("type", [
   pointAnchorSchema,
   textAnchorSchema,
   pageAnchorSchema
 ]);
-var displayNameSchema = z7.string().trim().min(1).max(64);
-var guestSchema = z7.object({
+var displayNameSchema = z8.string().trim().min(1).max(64);
+var guestSchema = z8.object({
   displayName: displayNameSchema,
-  guestId: z7.string().min(16)
+  guestId: z8.string().min(16)
 });
-var viaLabelSchema = z7.string().trim().min(1).max(64);
-var createCommentThreadSchema = z7.object({
+var viaLabelSchema = z8.string().trim().min(1).max(64);
+var createCommentThreadSchema = z8.object({
   anchor: anchorSchema,
-  body: z7.string().min(1).max(1e4),
+  body: z8.string().min(1).max(1e4),
   guest: guestSchema.optional(),
-  versionId: z7.string(),
+  versionId: z8.string(),
   via: viaLabelSchema.optional()
 });
-var createCommentMessageSchema = z7.object({
-  body: z7.string().min(1).max(1e4),
+var createCommentMessageSchema = z8.object({
+  body: z8.string().min(1).max(1e4),
   guest: guestSchema.optional(),
   via: viaLabelSchema.optional()
 });
-var editCommentMessageSchema = z7.object({
-  body: z7.string().min(1).max(1e4),
+var editCommentMessageSchema = z8.object({
+  body: z8.string().min(1).max(1e4),
   guest: guestSchema.optional()
 });
-var threadActionSchema = z7.object({
+var threadActionSchema = z8.object({
   guest: guestSchema.optional()
 });
-var reactionEmojiSchema = z7.string().max(64).transform(canonicalizeEmoji).refine((s) => SINGLE_EMOJI.test(s), { message: "Must be a single emoji." }).describe("A single emoji, e.g. \u{1F44D}");
-var toggleReactionSchema = z7.object({
+var reactionEmojiSchema = z8.string().max(64).transform(canonicalizeEmoji).refine((s) => SINGLE_EMOJI.test(s), { message: "Must be a single emoji." }).describe("A single emoji, e.g. \u{1F44D}");
+var toggleReactionSchema = z8.object({
   emoji: reactionEmojiSchema,
   guest: guestSchema.optional()
 });
-var commentAgentSchema = z7.object({
-  id: z7.string().nullable(),
-  label: z7.string()
+var commentAgentSchema = z8.object({
+  id: z8.string().nullable(),
+  label: z8.string()
 });
-var commentAuthorSchema = z7.object({
+var commentAuthorSchema = z8.object({
   agent: commentAgentSchema.nullable().default(null),
-  avatarUrl: z7.string().nullable(),
-  displayName: z7.string(),
-  guestId: z7.string().nullable(),
-  isViewer: z7.boolean(),
-  kind: z7.enum(["member", "guest"]),
+  avatarUrl: z8.string().nullable(),
+  displayName: z8.string(),
+  guestId: z8.string().nullable(),
+  isViewer: z8.boolean(),
+  kind: z8.enum(["member", "guest"]),
   // Optional "via" attribution (§6.4). Null for plain comments; a bounded
   // label the shell appends after the display name. Defaulted for the same
   // reason as `agent`: a server predating §6.4 omits the key entirely.
-  via: z7.string().nullable().default(null)
+  via: z8.string().nullable().default(null)
 });
-var messageReactionSchema = z7.object({
-  emoji: z7.string(),
-  reactors: z7.array(commentAuthorSchema)
+var messageReactionSchema = z8.object({
+  emoji: z8.string(),
+  reactors: z8.array(commentAuthorSchema)
 });
-var commentMessageSchema = z7.object({
+var commentMessageSchema = z8.object({
   author: commentAuthorSchema,
   // Empty string for a deleted message — the body is stripped server-side
   // (§6.7.1 tombstone), never sent to the client and hidden there.
-  body: z7.string(),
-  createdAt: z7.string(),
+  body: z8.string(),
+  createdAt: z8.string(),
   // Soft-deleted (§6.7.1). A tombstone keeps thread structure and replies;
   // the shell renders "Comment deleted" instead of the (absent) body.
-  deleted: z7.boolean(),
+  deleted: z8.boolean(),
   // Last edit time (§6.7.1), or null if never edited — drives the "edited"
   // badge. No edit history is kept.
-  editedAt: z7.string().nullable(),
-  id: z7.string(),
+  editedAt: z8.string().nullable(),
+  id: z8.string(),
   // Defaulted, not required: a new CLI parsing an older server's
   // response must not fail on the missing key.
-  reactions: z7.array(messageReactionSchema).default([])
+  reactions: z8.array(messageReactionSchema).default([])
 });
-var threadActorSchema = z7.object({
-  displayName: z7.string(),
-  kind: z7.enum(["member", "guest", "agent"])
+var threadActorSchema = z8.object({
+  displayName: z8.string(),
+  kind: z8.enum(["member", "guest", "agent"])
 });
-var commentThreadSchema = z7.object({
+var commentThreadSchema = z8.object({
   // §6.6.1 — set while open to signal "seen, working on it"; cleared on
   // reopen, kept (but superseded in display) once resolved. Defaulted so
   // clients parsing an older server's response don't fail.
-  acknowledgedAt: z7.string().nullable().default(null),
+  acknowledgedAt: z8.string().nullable().default(null),
   acknowledgedBy: threadActorSchema.nullable().default(null),
   anchor: anchorSchema,
-  artifactId: z7.string(),
-  createdAt: z7.string(),
+  artifactId: z8.string(),
+  createdAt: z8.string(),
   createdBy: commentAuthorSchema,
-  id: z7.string(),
-  messages: z7.array(commentMessageSchema),
+  id: z8.string(),
+  messages: z8.array(commentMessageSchema),
   // Null on threads resolved before actor recording existed, and always
   // null while open.
   resolvedBy: threadActorSchema.nullable().default(null),
-  status: z7.enum(["open", "resolved"]),
-  versionId: z7.string()
+  status: z8.enum(["open", "resolved"]),
+  versionId: z8.string()
 });
-var commentThreadListSchema = z7.object({
-  threads: z7.array(commentThreadSchema)
+var commentThreadListSchema = z8.object({
+  threads: z8.array(commentThreadSchema)
 });
-var commentExportQuerySchema = z7.object({
-  status: z7.enum(["open", "resolved", "all"]).default("open"),
-  version: z7.enum(["current", "all"]).default("current")
+var commentExportQuerySchema = z8.object({
+  status: z8.enum(["open", "resolved", "all"]).default("open"),
+  version: z8.enum(["current", "all"]).default("current")
 });
-var exportReactionSchema = z7.object({
-  count: z7.number().int().positive(),
-  emoji: z7.string()
+var exportReactionSchema = z8.object({
+  count: z8.number().int().positive(),
+  emoji: z8.string()
 });
-var commentExportReplySchema = z7.object({
-  author: z7.string(),
-  authorKind: z7.enum(["member", "guest"]),
-  body: z7.string(),
-  createdAt: z7.string(),
+var commentExportReplySchema = z8.object({
+  author: z8.string(),
+  authorKind: z8.enum(["member", "guest"]),
+  body: z8.string(),
+  createdAt: z8.string(),
   // Soft-delete tombstone (§6.7.1): body is "" when true.
-  deleted: z7.boolean(),
-  editedAt: z7.string().nullable(),
+  deleted: z8.boolean(),
+  editedAt: z8.string().nullable(),
   // The message id — what `edit`/`delete` target (§5.1).
-  id: z7.string(),
-  reactions: z7.array(exportReactionSchema).optional()
+  id: z8.string(),
+  reactions: z8.array(exportReactionSchema).optional()
 });
-var commentExportThreadSchema = z7.object({
+var commentExportThreadSchema = z8.object({
   // §6.6.1 — lets a polling agent skip threads it already acknowledged
   // (acknowledged threads stay in status=open exports on purpose).
-  acknowledgedAt: z7.string().nullable().default(null),
+  acknowledgedAt: z8.string().nullable().default(null),
   anchor: anchorSchema,
-  author: z7.string(),
-  authorKind: z7.enum(["member", "guest"]),
-  body: z7.string(),
-  createdAt: z7.string(),
-  deleted: z7.boolean(),
-  editedAt: z7.string().nullable(),
-  id: z7.string(),
+  author: z8.string(),
+  authorKind: z8.enum(["member", "guest"]),
+  body: z8.string(),
+  createdAt: z8.string(),
+  deleted: z8.boolean(),
+  editedAt: z8.string().nullable(),
+  id: z8.string(),
   // The opening message's id (distinct from the thread `id`) — `edit`/
   // `delete` operate on messages, so the CLI needs it to target the first
   // comment, not just the replies.
-  messageId: z7.string(),
-  reactions: z7.array(exportReactionSchema).optional(),
-  replies: z7.array(commentExportReplySchema),
+  messageId: z8.string(),
+  reactions: z8.array(exportReactionSchema).optional(),
+  replies: z8.array(commentExportReplySchema),
   resolvedBy: threadActorSchema.nullable().default(null),
-  status: z7.enum(["open", "resolved"]),
-  versionNumber: z7.number().int().positive()
+  status: z8.enum(["open", "resolved"]),
+  versionNumber: z8.number().int().positive()
 });
-var commentExportSchema = z7.object({
-  artifactId: z7.string(),
-  comments: z7.array(commentExportThreadSchema),
+var commentExportSchema = z8.object({
+  artifactId: z8.string(),
+  comments: z8.array(commentExportThreadSchema),
   // The artifact's current version (null before the first finalize).
-  versionNumber: z7.number().int().positive().nullable()
+  versionNumber: z8.number().int().positive().nullable()
 });
-var commentReadResponseSchema = z7.object({
-  lastSeenAt: z7.string()
+var commentReadResponseSchema = z8.object({
+  lastSeenAt: z8.string()
 });
 function elementLabel(el) {
   if (el.id) {
@@ -497,245 +541,579 @@ function elementLabel(el) {
   return classes.length ? `<${el.tag}.${classes.join(".")}>` : `<${el.tag}>`;
 }
 
+// ../shared/src/data.ts
+var DATA_MANIFEST_PATH = ".artifact/data.json";
+var DATA_NAME_RE = /^[a-z][a-z0-9_]*$/;
+var DATA_NAME_MAX = 64;
+var DATA_RESERVED_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "created_at",
+  "updated_at",
+  "created_by",
+  "mine"
+]);
+var DATA_LIMITS = {
+  artifactRateWindowSeconds: 3600,
+  artifactReadHourlyLimit: 1e4,
+  artifactWriteHourlyLimit: 1e3,
+  defaultReadRate: "120/minute/ip",
+  defaultWriteRate: "10/minute/ip",
+  maxCollections: 10,
+  maxFieldsPerCollection: 50,
+  /** Owner-plane batch insert: records per request. */
+  maxInsertBatch: 100,
+  maxListLimit: 200,
+  maxManifestBytes: 64 * 1024,
+  maxRecordBytes: 16 * 1024,
+  maxRecordsPerArtifact: 1e4
+};
+var DATA_ACCESS_DEFAULTS = {
+  delete: "owner",
+  insert: "owner",
+  read: "public",
+  update: "owner"
+};
+var DATA_RATE_LIMIT_RE = /^([1-9]\d{0,5})\/(hour|minute)\/ip$/;
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function validateFieldValue(name, field, value, errors) {
+  switch (field.type) {
+    case "string": {
+      if (typeof value !== "string") {
+        errors.push(`${name}: expected a string`);
+        return value;
+      }
+      const s = field.trim ? value.trim() : value;
+      if (field.maxLength !== void 0 && s.length > field.maxLength) {
+        errors.push(`${name}: longer than maxLength ${field.maxLength}`);
+      }
+      return s;
+    }
+    case "number":
+    case "integer": {
+      if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
+        errors.push(`${name}: expected a ${field.type}`);
+        return value;
+      }
+      if (field.type === "integer" && !Number.isInteger(value)) {
+        errors.push(`${name}: expected an integer`);
+      }
+      if (field.minimum !== void 0 && value < field.minimum) {
+        errors.push(`${name}: below minimum ${field.minimum}`);
+      }
+      if (field.maximum !== void 0 && value > field.maximum) {
+        errors.push(`${name}: above maximum ${field.maximum}`);
+      }
+      return value;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        errors.push(`${name}: expected a boolean`);
+      }
+      return value;
+    }
+    case "datetime": {
+      if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+        errors.push(`${name}: expected an ISO 8601 datetime string`);
+      }
+      return value;
+    }
+    case "url": {
+      if (typeof value !== "string" || !canParseUrl(value)) {
+        errors.push(`${name}: expected a valid URL`);
+      }
+      return value;
+    }
+    case "email": {
+      if (typeof value !== "string" || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+        errors.push(`${name}: expected an email address`);
+      }
+      return value;
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        errors.push(`${name}: expected an array`);
+        return value;
+      }
+      if (field.maxLength !== void 0 && value.length > field.maxLength) {
+        errors.push(`${name}: more than maxLength ${field.maxLength} items`);
+      }
+      return value;
+    }
+    case "object": {
+      if (!isPlainObject(value)) {
+        errors.push(`${name}: expected an object`);
+      }
+      return value;
+    }
+    default: {
+      errors.push(`${name}: unknown field type`);
+      return value;
+    }
+  }
+}
+function canParseUrl(value) {
+  try {
+    return Boolean(new URL(value));
+  } catch {
+    return false;
+  }
+}
+function validateRecordInput(collection, input, opts = {}) {
+  if (!isPlainObject(input)) {
+    return { errors: ["record body must be a JSON object"], ok: false };
+  }
+  const errors = [];
+  const data2 = {};
+  for (const key of Object.keys(input)) {
+    if (DATA_RESERVED_FIELDS.has(key)) {
+      errors.push(`${key}: reserved field (server-stamped)`);
+      continue;
+    }
+    const field = collection.fields[key];
+    if (!(Object.hasOwn(collection.fields, key) && field)) {
+      errors.push(`${key}: not a declared field`);
+      continue;
+    }
+    const value = input[key];
+    if (value === null || value === void 0) {
+      if (!field.required) {
+        data2[key] = null;
+      } else if (opts.partial) {
+        errors.push(`${key}: required (cannot be null)`);
+      }
+      continue;
+    }
+    data2[key] = validateFieldValue(key, field, value, errors);
+  }
+  if (opts.partial) {
+    if (Object.keys(data2).length === 0 && errors.length === 0) {
+      errors.push("no fields to update");
+    }
+  } else {
+    for (const [name, field] of Object.entries(collection.fields)) {
+      const present = data2[name] !== void 0 && data2[name] !== null;
+      if (present) {
+        continue;
+      }
+      if (field.default !== void 0) {
+        data2[name] = field.default;
+      } else if (field.required) {
+        errors.push(`${name}: required`);
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { errors, ok: false };
+  }
+  return { data: data2, ok: true };
+}
+
+// ../shared/src/data-api.ts
+import { z as z9 } from "zod";
+var dataRecordSchema = z9.object({
+  created_at: z9.string(),
+  created_by: z9.string().nullable(),
+  id: z9.string(),
+  updated_at: z9.string()
+}).catchall(z9.unknown());
+var dataPublicRecordSchema = z9.object({
+  created_at: z9.string(),
+  created_by: z9.never().optional(),
+  id: z9.string(),
+  mine: z9.boolean(),
+  updated_at: z9.string()
+}).catchall(z9.unknown());
+var dataPublicListResponseSchema = z9.object({
+  nextCursor: z9.string().nullable(),
+  records: z9.array(dataPublicRecordSchema)
+});
+var dataListResponseSchema = z9.object({
+  nextCursor: z9.string().nullable(),
+  records: z9.array(dataRecordSchema)
+});
+var dataRecordResponseSchema = z9.object({ record: dataRecordSchema });
+var dataBatchInsertResponseSchema = z9.object({
+  records: z9.array(dataRecordSchema)
+});
+var dataCollectionSummarySchema = z9.object({
+  access: z9.record(z9.string(), z9.string()).optional(),
+  count: z9.number().int().nonnegative().optional(),
+  name: z9.string(),
+  rateLimit: z9.string().optional()
+});
+var dataSummaryResponseSchema = z9.object({
+  collections: z9.array(dataCollectionSummarySchema),
+  enabled: z9.boolean()
+});
+var dataClearResponseSchema = z9.object({
+  cleared: z9.number().int().nonnegative()
+});
+
+// ../shared/src/data-manifest.ts
+import { z as z10 } from "zod";
+var nameSchema = z10.string().max(DATA_NAME_MAX).regex(DATA_NAME_RE, "must match ^[a-z][a-z0-9_]*$");
+var fieldTypeSchema = z10.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "datetime",
+  "url",
+  "email",
+  "array",
+  "object"
+]);
+var fieldSchema = z10.strictObject({
+  default: z10.unknown().optional(),
+  maximum: z10.number().optional(),
+  maxLength: z10.number().int().positive().optional(),
+  minimum: z10.number().optional(),
+  required: z10.boolean().optional(),
+  trim: z10.boolean().optional(),
+  type: fieldTypeSchema
+}).superRefine((field, ctx) => {
+  if (field.default === void 0) {
+    return;
+  }
+  if (!defaultMatchesType(field)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `default value does not match type "${field.type}"`,
+      path: ["default"]
+    });
+  }
+});
+function defaultMatchesType(field) {
+  if (field.required && field.default === null) {
+    return false;
+  }
+  return validateRecordInput(
+    {
+      access: DATA_ACCESS_DEFAULTS,
+      fields: { value: { ...field, default: void 0 } }
+    },
+    { value: field.default }
+  ).ok;
+}
+var accessLevelSchema = z10.enum(["public", "creator", "owner", "none"]);
+var accessSchema = z10.strictObject({
+  delete: accessLevelSchema.default("owner"),
+  insert: accessLevelSchema.default("owner"),
+  read: accessLevelSchema.default("public"),
+  update: accessLevelSchema.default("owner")
+}).prefault({});
+var collectionSchema = z10.strictObject({
+  access: accessSchema,
+  fields: z10.record(nameSchema, fieldSchema),
+  publicMutation: z10.literal("open").optional(),
+  rateLimit: z10.string().regex(DATA_RATE_LIMIT_RE, 'expected "N/hour/ip" or "N/minute/ip"').optional()
+}).superRefine((collection, ctx) => {
+  const fieldNames = Object.keys(collection.fields);
+  if (fieldNames.length > DATA_LIMITS.maxFieldsPerCollection) {
+    ctx.addIssue({
+      code: "custom",
+      message: `at most ${DATA_LIMITS.maxFieldsPerCollection} fields per collection`,
+      path: ["fields"]
+    });
+  }
+  for (const name of fieldNames) {
+    if (DATA_RESERVED_FIELDS.has(name)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `"${name}" is reserved (server-stamped)`,
+        path: ["fields", name]
+      });
+    }
+  }
+  for (const action of ["update", "delete"]) {
+    if (collection.access[action] === "public" && collection.publicMutation !== "open") {
+      ctx.addIssue({
+        code: "custom",
+        message: `access.${action} may only be "public" alongside "publicMutation": "open"`,
+        path: ["access", action]
+      });
+    }
+  }
+});
+var dataManifestSchema = z10.strictObject({
+  collections: z10.record(nameSchema, collectionSchema)
+}).superRefine((manifest, ctx) => {
+  if (Object.keys(manifest.collections).length > DATA_LIMITS.maxCollections) {
+    ctx.addIssue({
+      code: "custom",
+      message: `at most ${DATA_LIMITS.maxCollections} collections`,
+      path: ["collections"]
+    });
+  }
+});
+function parseDataManifest(text) {
+  if (new TextEncoder().encode(text).length > DATA_LIMITS.maxManifestBytes) {
+    return {
+      errors: [`manifest larger than ${DATA_LIMITS.maxManifestBytes} bytes`],
+      ok: false
+    };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (err) {
+    return {
+      errors: [`not valid JSON: ${err instanceof Error ? err.message : err}`],
+      ok: false
+    };
+  }
+  const parsed = dataManifestSchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      errors: parsed.error.issues.map(
+        (issue) => issue.path.length ? `${issue.path.join(".")}: ${issue.message}` : issue.message
+      ),
+      ok: false
+    };
+  }
+  return { config: parsed.data, ok: true };
+}
+
 // ../shared/src/errors.ts
-import { z as z8 } from "zod";
-var apiErrorSchema = z8.object({
-  code: z8.string(),
-  docsUrl: z8.string().url(),
-  message: z8.string(),
-  retryAfter: z8.number().int().positive().optional()
+import { z as z11 } from "zod";
+var apiErrorSchema = z11.object({
+  code: z11.string(),
+  docsUrl: z11.string().url(),
+  message: z11.string(),
+  retryAfter: z11.number().int().positive().optional(),
+  scope: z11.enum(["ip", "artifact"]).optional()
 });
 
 // ../shared/src/feedback.ts
-import { z as z9 } from "zod";
-var feedbackRequestSchema = z9.object({
-  email: z9.string().trim().toLowerCase().email().optional().or(z9.literal("")),
-  message: z9.string().trim().min(1).max(4e3)
+import { z as z12 } from "zod";
+var feedbackRequestSchema = z12.object({
+  email: z12.string().trim().toLowerCase().email().optional().or(z12.literal("")),
+  message: z12.string().trim().min(1).max(4e3)
 });
-var feedbackResponseSchema = z9.object({
-  sent: z9.literal(true)
+var feedbackResponseSchema = z12.object({
+  sent: z12.literal(true)
 });
 
 // ../shared/src/grants.ts
-import { z as z10 } from "zod";
-var grantRoleSchema = z10.enum(["viewer"]);
-var createGrantSchema = z10.object({
-  email: z10.string().trim().toLowerCase().email().optional(),
+import { z as z13 } from "zod";
+var grantRoleSchema = z13.enum(["viewer"]);
+var createGrantSchema = z13.object({
+  email: z13.string().trim().toLowerCase().email().optional(),
   role: grantRoleSchema.default("viewer"),
-  userId: z10.string().min(1).optional()
+  userId: z13.string().min(1).optional()
 }).refine((body) => Boolean(body.email) !== Boolean(body.userId), {
   message: "provide exactly one of email or userId"
 });
-var grantSchema = z10.object({
-  createdAt: z10.string(),
-  email: z10.string().email().nullable(),
-  expiresAt: z10.string().nullable(),
-  id: z10.string(),
+var grantSchema = z13.object({
+  createdAt: z13.string(),
+  email: z13.string().email().nullable(),
+  expiresAt: z13.string().nullable(),
+  id: z13.string(),
   // The subject's avatar once they have an account; null otherwise.
-  image: z10.string().nullable(),
+  image: z13.string().nullable(),
   // Present on the invited account after redemption / when granting an
   // existing user; null for a still-pending email invite.
-  name: z10.string().nullable(),
-  redeemedAt: z10.string().nullable(),
+  name: z13.string().nullable(),
+  redeemedAt: z13.string().nullable(),
   role: grantRoleSchema,
   // Shown as "· pending" beside the role until the link is redeemed.
-  status: z10.enum(["pending", "active"]),
+  status: z13.enum(["pending", "active"]),
   // Display fragment of the live invitation token, or null once redeemed.
-  tokenPrefix: z10.string().nullable(),
-  userId: z10.string().nullable()
+  tokenPrefix: z13.string().nullable(),
+  userId: z13.string().nullable()
 });
 var createdGrantSchema = grantSchema.extend({
-  url: z10.string().url()
+  url: z13.string().url()
 });
-var grantListResponseSchema = z10.object({
-  grants: z10.array(grantSchema),
+var grantListResponseSchema = z13.object({
+  grants: z13.array(grantSchema),
   // The artifact's current general-access value, so the share surface can
   // render the "General access" line without a second read.
-  visibility: z10.enum(["public", "unlisted", "workspace", "private"]),
+  visibility: z13.enum(["public", "unlisted", "workspace", "private"]),
   // The owning workspace's logo, so the share modal can draw the workspace
   // itself rather than a generic glyph. Null when none was uploaded.
-  workspaceLogo: z10.string().nullable().optional(),
+  workspaceLogo: z13.string().nullable().optional(),
   // The owning workspace's display name, so "People with access" can name the
   // audience `workspace` visibility actually admits ("All Acme members") rather
   // than leaving an empty list to imply nobody. Null for a workspace-less
   // artifact; optional so an older server still parses.
-  workspaceName: z10.string().nullable().optional()
+  workspaceName: z13.string().nullable().optional()
 });
-var revokeGrantResponseSchema = z10.object({
-  revoked: z10.literal(true)
+var revokeGrantResponseSchema = z13.object({
+  revoked: z13.literal(true)
 });
-var acceptGrantSchema = z10.object({
-  token: z10.string().min(1)
+var acceptGrantSchema = z13.object({
+  token: z13.string().min(1)
 });
-var acceptGrantResponseSchema = z10.object({
-  artifactId: z10.string(),
+var acceptGrantResponseSchema = z13.object({
+  artifactId: z13.string(),
   // The review shell URL to land on, carrying ?invited=1 for the banner.
-  artifactUrl: z10.string().url(),
-  slug: z10.string(),
-  title: z10.string()
-});
-var workspaceGuestSchema = z10.object({
-  artifacts: z10.array(
-    z10.object({
-      artifactId: z10.string(),
-      grantId: z10.string(),
-      slug: z10.string(),
-      status: z10.enum(["pending", "active"]),
-      title: z10.string()
+  artifactUrl: z13.string().url(),
+  slug: z13.string(),
+  title: z13.string()
+});
+var workspaceGuestSchema = z13.object({
+  artifacts: z13.array(
+    z13.object({
+      artifactId: z13.string(),
+      grantId: z13.string(),
+      slug: z13.string(),
+      status: z13.enum(["pending", "active"]),
+      title: z13.string()
     })
   ),
-  email: z10.string().nullable(),
-  image: z10.string().nullable(),
-  name: z10.string().nullable(),
-  userId: z10.string().nullable()
-});
-var workspaceGuestListResponseSchema = z10.object({
-  guests: z10.array(workspaceGuestSchema)
-});
-var sharedWithMeArtifactSchema = z10.object({
-  artifactId: z10.string(),
-  slug: z10.string(),
-  title: z10.string(),
-  url: z10.string().url(),
+  email: z13.string().nullable(),
+  image: z13.string().nullable(),
+  name: z13.string().nullable(),
+  userId: z13.string().nullable()
+});
+var workspaceGuestListResponseSchema = z13.object({
+  guests: z13.array(workspaceGuestSchema)
+});
+var sharedWithMeArtifactSchema = z13.object({
+  artifactId: z13.string(),
+  slug: z13.string(),
+  title: z13.string(),
+  url: z13.string().url(),
   // Who shared it, for the "Shared with me" list.
-  workspaceName: z10.string()
+  workspaceName: z13.string()
 });
-var sharedWithMeListResponseSchema = z10.object({
-  artifacts: z10.array(sharedWithMeArtifactSchema)
+var sharedWithMeListResponseSchema = z13.object({
+  artifacts: z13.array(sharedWithMeArtifactSchema)
 });
 
 // ../shared/src/html-meta.ts
 var HEAD_SCAN_CHARS = 64 * 1024;
 
 // ../shared/src/me.ts
-import { z as z12 } from "zod";
+import { z as z15 } from "zod";
 
 // ../shared/src/workspaces.ts
-import { z as z11 } from "zod";
+import { z as z14 } from "zod";
 var WORKSPACE_HANDLE_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,30}[a-z0-9])$/;
-var workspaceHandleUnavailableReasonSchema = z11.enum([
+var workspaceHandleUnavailableReasonSchema = z14.enum([
   "held",
   "invalid",
   "reserved",
   "taken"
 ]);
-var workspaceHandleAvailabilitySchema = z11.object({
-  available: z11.boolean(),
-  handle: z11.string(),
+var workspaceHandleAvailabilitySchema = z14.object({
+  available: z14.boolean(),
+  handle: z14.string(),
   // Human-readable sentence for the field hint; null when available.
-  message: z11.string().nullable(),
+  message: z14.string().nullable(),
   reason: workspaceHandleUnavailableReasonSchema.nullable()
 });
-var workspaceRoleSchema = z11.enum(["owner", "admin", "member"]);
-var workspaceInviteRoleSchema = z11.enum(["admin", "member"]);
-var workspaceHandleSchema = z11.string().min(3).max(32).regex(WORKSPACE_HANDLE_PATTERN, {
+var workspaceRoleSchema = z14.enum(["owner", "admin", "member"]);
+var workspaceInviteRoleSchema = z14.enum(["admin", "member"]);
+var workspaceHandleSchema = z14.string().min(3).max(32).regex(WORKSPACE_HANDLE_PATTERN, {
   message: "handle must be lowercase letters, digits, and hyphens, with no leading/trailing hyphen"
 });
-var createWorkspaceSchema = z11.object({
+var createWorkspaceSchema = z14.object({
   handle: workspaceHandleSchema.optional(),
-  name: z11.string().trim().min(1).max(100)
+  name: z14.string().trim().min(1).max(100)
 });
-var updateWorkspaceSchema = z11.object({
+var updateWorkspaceSchema = z14.object({
   handle: workspaceHandleSchema.optional(),
-  name: z11.string().trim().min(1).max(100).optional()
+  name: z14.string().trim().min(1).max(100).optional()
 }).refine((body) => body.handle !== void 0 || body.name !== void 0, {
   message: "provide at least one of name or handle"
 });
-var workspaceSchema = z11.object({
-  createdAt: z11.string(),
-  handle: z11.string(),
+var workspaceSchema = z14.object({
+  createdAt: z14.string(),
+  handle: z14.string(),
   // ISO timestamp when `{handle}.artifact.cafe` was provisioned, or null.
   // Set by the one-time, self-serve enable flow (§4.4); never auto at
   // create, and always null for personal workspaces.
-  hostnameProvisionedAt: z11.string().nullable(),
-  id: z11.string(),
+  hostnameProvisionedAt: z14.string().nullable(),
+  id: z14.string(),
   // Auto-provisioned solo workspace, one per user: non-deletable, takes
   // no members, renameable like any workspace.
-  isPersonal: z11.boolean(),
+  isPersonal: z14.boolean(),
   // Uploaded logo URL, or null for the initials fallback. Set through the
   // dedicated /workspaces/:id/avatar route, never the generic update.
-  logo: z11.string().nullable(),
-  name: z11.string(),
+  logo: z14.string().nullable(),
+  name: z14.string(),
   role: workspaceRoleSchema.nullable(),
-  updatedAt: z11.string()
+  updatedAt: z14.string()
 });
-var workspaceListResponseSchema = z11.object({
-  workspaces: z11.array(workspaceSchema)
+var workspaceListResponseSchema = z14.object({
+  workspaces: z14.array(workspaceSchema)
 });
-var deleteWorkspaceResponseSchema = z11.object({
-  deleted: z11.literal(true)
+var deleteWorkspaceResponseSchema = z14.object({
+  deleted: z14.literal(true)
 });
-var workspaceMemberSchema = z11.object({
-  createdAt: z11.string(),
-  email: z11.string().email(),
-  image: z11.string().nullable(),
-  name: z11.string(),
+var workspaceMemberSchema = z14.object({
+  createdAt: z14.string(),
+  email: z14.string().email(),
+  image: z14.string().nullable(),
+  name: z14.string(),
   role: workspaceRoleSchema,
-  userId: z11.string()
+  userId: z14.string()
 });
-var workspaceMemberListResponseSchema = z11.object({
-  members: z11.array(workspaceMemberSchema)
+var workspaceMemberListResponseSchema = z14.object({
+  members: z14.array(workspaceMemberSchema)
 });
-var updateWorkspaceMemberSchema = z11.object({
+var updateWorkspaceMemberSchema = z14.object({
   role: workspaceRoleSchema
 });
-var removeWorkspaceMemberResponseSchema = z11.object({
-  removed: z11.literal(true)
+var removeWorkspaceMemberResponseSchema = z14.object({
+  removed: z14.literal(true)
 });
-var createWorkspaceInviteSchema = z11.object({
-  email: z11.string().trim().toLowerCase().email().optional(),
-  expiresAt: z11.string().datetime(),
-  maxUses: z11.number().int().positive().optional(),
+var createWorkspaceInviteSchema = z14.object({
+  email: z14.string().trim().toLowerCase().email().optional(),
+  expiresAt: z14.string().datetime(),
+  maxUses: z14.number().int().positive().optional(),
   role: workspaceInviteRoleSchema
 });
-var workspaceInviteSchema = z11.object({
-  createdAt: z11.string(),
-  email: z11.string().email().nullable(),
-  expiresAt: z11.string(),
-  id: z11.string(),
-  maxUses: z11.number().int().positive().nullable(),
+var workspaceInviteSchema = z14.object({
+  createdAt: z14.string(),
+  email: z14.string().email().nullable(),
+  expiresAt: z14.string(),
+  id: z14.string(),
+  maxUses: z14.number().int().positive().nullable(),
   role: workspaceInviteRoleSchema,
-  tokenPrefix: z11.string(),
-  useCount: z11.number().int().nonnegative()
+  tokenPrefix: z14.string(),
+  useCount: z14.number().int().nonnegative()
 });
 var createdWorkspaceInviteSchema = workspaceInviteSchema.extend({
-  url: z11.string().url()
+  url: z14.string().url()
 });
-var workspaceInviteListResponseSchema = z11.object({
-  invites: z11.array(workspaceInviteSchema)
+var workspaceInviteListResponseSchema = z14.object({
+  invites: z14.array(workspaceInviteSchema)
 });
-var revokeWorkspaceInviteResponseSchema = z11.object({
-  revoked: z11.literal(true)
+var revokeWorkspaceInviteResponseSchema = z14.object({
+  revoked: z14.literal(true)
 });
-var acceptWorkspaceInviteSchema = z11.object({
-  token: z11.string().min(1)
+var acceptWorkspaceInviteSchema = z14.object({
+  token: z14.string().min(1)
 });
-var acceptWorkspaceInviteResponseSchema = z11.object({
+var acceptWorkspaceInviteResponseSchema = z14.object({
   role: workspaceRoleSchema,
   workspace: workspaceSchema
 });
-var folderVisibilitySchema = z11.enum(["public", "workspace"]);
-var artifactVisibilitySchema = z11.enum([
+var folderVisibilitySchema = z14.enum(["public", "workspace"]);
+var artifactVisibilitySchema = z14.enum([
   "public",
   "unlisted",
   "workspace",
   "private"
 ]);
-var createFolderSchema = z11.object({
+var createFolderSchema = z14.object({
   // Optional custom icon; omitted (or null) leaves the default glyph.
   emoji: iconEmojiSchema.optional(),
-  name: z11.string().trim().min(1).max(100),
+  name: z14.string().trim().min(1).max(100),
   visibility: folderVisibilitySchema
 });
-var updateFolderSchema = z11.object({
+var updateFolderSchema = z14.object({
   // With `visibility`: bulk-update the folder's artifacts to match
   // (SPEC-2 §3.4 "Changing a folder's visibility offers a bulk update").
-  cascade: z11.boolean().optional(),
+  cascade: z14.boolean().optional(),
   // Explicit null clears the icon back to the default glyph, so this is
   // a field where "sent as null" and "omitted" mean different things.
   emoji: iconEmojiSchema.optional(),
-  name: z11.string().trim().min(1).max(100).optional(),
-  sortOrder: z11.number().int().min(0).optional(),
+  name: z14.string().trim().min(1).max(100).optional(),
+  sortOrder: z14.number().int().min(0).optional(),
   visibility: folderVisibilitySchema.optional()
 }).refine(
   (body) => body.name !== void 0 || body.visibility !== void 0 || body.sortOrder !== void 0 || body.emoji !== void 0,
@@ -743,93 +1121,95 @@ var updateFolderSchema = z11.object({
 ).refine((body) => !body.cascade || body.visibility !== void 0, {
   message: "cascade requires visibility"
 });
-var folderSchema = z11.object({
-  createdAt: z11.string(),
+var folderSchema = z14.object({
+  createdAt: z14.string(),
   // Custom icon, or null to render the default folder glyph.
-  emoji: z11.string().nullable(),
-  id: z11.string(),
-  name: z11.string(),
+  emoji: z14.string().nullable(),
+  id: z14.string(),
+  name: z14.string(),
   // Permalink segment for the public folder page (/w/{handle}/f/{slug}).
   // Server-derived from the name; renames regenerate it.
-  slug: z11.string(),
-  sortOrder: z11.number().int(),
-  updatedAt: z11.string(),
+  slug: z14.string(),
+  sortOrder: z14.number().int(),
+  updatedAt: z14.string(),
   visibility: folderVisibilitySchema,
-  workspaceId: z11.string()
+  workspaceId: z14.string()
 });
-var folderListResponseSchema = z11.object({
-  folders: z11.array(folderSchema)
+var folderListResponseSchema = z14.object({
+  folders: z14.array(folderSchema)
 });
-var deleteFolderResponseSchema = z11.object({
-  deleted: z11.literal(true)
+var deleteFolderResponseSchema = z14.object({
+  deleted: z14.literal(true)
 });
-var workspaceArtifactSchema = z11.object({
-  createdAt: z11.string(),
-  currentVersionNumber: z11.number().int().nullable(),
+var workspaceArtifactSchema = z14.object({
+  autoDeleteAt: z14.string().datetime().nullable().optional(),
+  createdAt: z14.string(),
+  currentVersionNumber: z14.number().int().nullable(),
   // Custom icon, or null to render the default document glyph.
-  emoji: z11.string().nullable(),
-  folderId: z11.string().nullable(),
-  id: z11.string(),
-  openCommentCount: z11.number().int().nonnegative(),
+  emoji: z14.string().nullable(),
+  expiresAt: z14.string().datetime().nullable().optional(),
+  folderId: z14.string().nullable(),
+  id: z14.string(),
+  openCommentCount: z14.number().int().nonnegative(),
   reviewMode: reviewModeSchema,
-  slug: z11.string(),
-  title: z11.string(),
-  updatedAt: z11.string(),
-  url: z11.string().url(),
-  versionCount: z11.number().int().nonnegative(),
+  slug: z14.string(),
+  title: z14.string(),
+  updatedAt: z14.string(),
+  url: z14.string().url(),
+  versionCount: z14.number().int().nonnegative(),
   visibility: artifactVisibilitySchema
 });
-var workspaceArtifactListResponseSchema = z11.object({
-  artifacts: z11.array(workspaceArtifactSchema)
+var workspaceArtifactListResponseSchema = z14.object({
+  artifacts: z14.array(workspaceArtifactSchema)
 });
-var workspaceArtifactSearchResultSchema = z11.object({
-  id: z11.string(),
-  slug: z11.string(),
-  title: z11.string()
+var workspaceArtifactSearchResultSchema = z14.object({
+  id: z14.string(),
+  slug: z14.string(),
+  title: z14.string()
 });
-var workspaceArtifactSearchResponseSchema = z11.object({
-  results: z11.array(workspaceArtifactSearchResultSchema)
+var workspaceArtifactSearchResponseSchema = z14.object({
+  results: z14.array(workspaceArtifactSearchResultSchema)
 });
 
 // ../shared/src/me.ts
-var personSchema = z12.object({
-  image: z12.string().nullable(),
-  name: z12.string()
+var personSchema = z15.object({
+  image: z15.string().nullable(),
+  name: z15.string()
 });
-var ownArtifactSchema = z12.object({
+var ownArtifactSchema = z15.object({
+  autoDeleteAt: z15.string().datetime().nullable().optional(),
   // Everyone else who has published a version, oldest first. Any member may
   // publish a new one (SPEC-2 §5.1), so an artifact's byline is often more
   // than one person and the card stacks their faces rather than crediting
   // whoever shipped last. Excludes `publishedBy`; empty on a solo artifact.
-  coPublishers: z12.array(personSchema),
-  createdAt: z12.string(),
+  coPublishers: z15.array(personSchema),
+  createdAt: z15.string(),
   // SPEC-2 §5.1 — who *made* the artifact: the author of its first
   // finalized version, the same row `viewerCanManage` is decided on. Not
   // the same person as `publishedBy` once an agent ships v2, which is why
   // the dashboard filters on both. Null for a token-only publish.
-  createdBy: z12.object({ image: z12.string().nullable(), name: z12.string() }).nullable(),
-  currentVersionNumber: z12.number().nullable(),
+  createdBy: z15.object({ image: z15.string().nullable(), name: z15.string() }).nullable(),
+  currentVersionNumber: z15.number().nullable(),
   // Custom icon, or null to render the default document glyph.
-  emoji: z12.string().nullable(),
-  // Owned artifacts normally never expire; non-null only while an
-  // expiry is still set (e.g. an unclaimed publish surfaced here later).
-  expiresAt: z12.string().nullable(),
+  emoji: z15.string().nullable(),
+  // Effective expiry: explicit temporary lifetime or anonymous retention.
+  expiresAt: z15.string().nullable(),
   // SPEC-2 §8.4 — the containing folder for workspace-owned artifacts;
   // both null for personal artifacts. `folderId` drives the dashboard's
   // move control and folder filter; `folderName` is the display label,
   // `folderEmoji` its icon (null = the default folder glyph).
-  folderEmoji: z12.string().nullable(),
-  folderId: z12.string().nullable(),
-  folderName: z12.string().nullable(),
+  folderEmoji: z15.string().nullable(),
+  folderId: z15.string().nullable(),
+  folderName: z15.string().nullable(),
   // Whether a publish token is still active — revocable from the
   // dashboard (§6.18); the token itself is never returned.
-  hasPublishToken: z12.boolean(),
+  hasPublishToken: z15.boolean(),
   // Owner preference: hide the version list from reviewers in the review
   // shell. Managers still see it.
-  hideVersions: z12.boolean(),
-  id: z12.string(),
-  openThreads: z12.number(),
-  protected: z12.boolean(),
+  hideVersions: z15.boolean(),
+  id: z15.string(),
+  openThreads: z15.number(),
+  protected: z15.boolean(),
   // Who published the current version (falling back to the claiming
   // owner) — the dashboard shows a name and avatar per artifact so a
   // shared workspace reads as people's work, not anonymous rows. Null
@@ -838,44 +1218,44 @@ var ownArtifactSchema = z12.object({
   // SPEC-2 §5.8 — the review dial, so the dashboard's settings dialog can
   // render current state without a second fetch.
   reviewMode: reviewModeSchema,
-  slug: z12.string(),
-  title: z12.string(),
-  totalViews: z12.number(),
+  slug: z15.string(),
+  title: z15.string(),
+  totalViews: z15.number(),
   // SPEC §6.20 — messages by others newer than the viewer's last-seen
   // watermark. 0 for signed-out/API-key-less contexts.
-  unreadComments: z12.number(),
-  updatedAt: z12.string(),
-  url: z12.string(),
-  versionCount: z12.number(),
+  unreadComments: z15.number(),
+  updatedAt: z15.string(),
+  url: z15.string(),
+  versionCount: z15.number(),
   // SPEC-2 §5.1 — whether the caller clears the manage bar for this
   // artifact (workspace admin, or the person who first published it).
   // Only a manager's folder move inherits the folder's visibility, so the
   // dashboard warns exactly the people the change can actually affect, and
   // only a manager is offered the Share entry (§5.7).
-  viewerCanManage: z12.boolean(),
+  viewerCanManage: z15.boolean(),
   // SPEC-2 §5.2 — the artifact's own visibility, the single enforcement
   // source. The dashboard needs it to tell whether a folder move would
   // widen exposure before it sends the PATCH (§3.4), and to render the
   // audience glyph — one per level — on rows and cards (§5.7).
   visibility: artifactVisibilitySchema
 });
-var ownArtifactsResponseSchema = z12.object({
-  artifacts: z12.array(ownArtifactSchema)
+var ownArtifactsResponseSchema = z15.object({
+  artifacts: z15.array(ownArtifactSchema)
 });
-var revokePublishTokenResponseSchema = z12.object({
-  revoked: z12.boolean()
+var revokePublishTokenResponseSchema = z15.object({
+  revoked: z15.boolean()
 });
 
 // ../shared/src/owner.ts
-import { z as z13 } from "zod";
+import { z as z16 } from "zod";
 var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,61}[a-z0-9])$/;
-var claimResponseSchema = z13.object({
-  artifactId: z13.string(),
-  slug: z13.string(),
-  title: z13.string(),
-  url: z13.string().url()
+var claimResponseSchema = z16.object({
+  artifactId: z16.string(),
+  slug: z16.string(),
+  title: z16.string(),
+  url: z16.string().url()
 });
-var updateArtifactSchema = z13.object({
+var updateArtifactSchema = z16.object({
   // Custom icon; explicit null clears it back to the default glyph.
   // Part of what the artifact *is* (like the title), so it takes the
   // same manage rights as title/slug — not the member-level folder move.
@@ -883,159 +1263,159 @@ var updateArtifactSchema = z13.object({
   // SPEC-2 §6.4 — placement + visibility. `folderId: null` clears the
   // folder; `workspaceId: null` moves the artifact out of its workspace
   // (§5.5 ownership transfer).
-  folderId: z13.string().min(1).nullable().optional(),
+  folderId: z16.string().min(1).nullable().optional(),
   // Keep the version list out of the review shell. Presentation only:
   // versions stay immutable, and a `/vN/` URL still resolves.
-  hideVersions: z13.boolean().optional(),
-  slug: z13.string().min(3).max(63).regex(SLUG_PATTERN, {
+  hideVersions: z16.boolean().optional(),
+  slug: z16.string().min(3).max(63).regex(SLUG_PATTERN, {
     message: "slug must be lowercase letters, digits, and hyphens, with no leading/trailing hyphen"
   }).optional(),
-  title: z13.string().min(1).max(200).optional(),
+  title: z16.string().min(1).max(200).optional(),
   visibility: artifactVisibilitySchema.optional(),
-  workspaceId: z13.string().min(1).nullable().optional()
+  workspaceId: z16.string().min(1).nullable().optional()
 }).refine(
   (body) => body.title !== void 0 || body.slug !== void 0 || body.visibility !== void 0 || body.folderId !== void 0 || body.workspaceId !== void 0 || body.emoji !== void 0 || body.hideVersions !== void 0,
   {
     message: "provide at least one of title, slug, visibility, folderId, workspaceId, emoji, hideVersions"
   }
 );
-var deleteArtifactResponseSchema = z13.object({
-  deleted: z13.literal(true)
+var deleteArtifactResponseSchema = z16.object({
+  deleted: z16.literal(true)
 });
 
 // ../shared/src/presence.ts
-import { z as z14 } from "zod";
+import { z as z17 } from "zod";
 var AGENT_STATES = ["listening", "editing", "publishing"];
-var agentStateSchema = z14.enum(AGENT_STATES);
+var agentStateSchema = z17.enum(AGENT_STATES);
 var AGENT_PRESENCE = {
   editingTtlSeconds: 300,
   heartbeatSeconds: 15,
   shellPollSeconds: 15,
   ttlSeconds: 45
 };
-var agentHeartbeatBodySchema = z14.object({
+var agentHeartbeatBodySchema = z17.object({
   state: agentStateSchema.optional()
 });
-var agentHeartbeatResponseSchema = z14.object({
-  listening: z14.literal(true),
+var agentHeartbeatResponseSchema = z17.object({
+  listening: z17.literal(true),
   state: agentStateSchema.optional(),
-  ttlSeconds: z14.number().int().positive()
+  ttlSeconds: z17.number().int().positive()
 });
-var agentPresenceSchema = z14.object({
-  agent: z14.object({ id: z14.string().nullable(), label: z14.string() }).nullable().default(null),
-  listening: z14.boolean(),
+var agentPresenceSchema = z17.object({
+  agent: z17.object({ id: z17.string().nullable(), label: z17.string() }).nullable().default(null),
+  listening: z17.boolean(),
   state: agentStateSchema.nullable().optional(),
-  versionNumber: z14.number().int().positive().nullable()
+  versionNumber: z17.number().int().positive().nullable()
 });
 
 // ../shared/src/protection.ts
-import { z as z15 } from "zod";
+import { z as z18 } from "zod";
 var PASSWORD_MIN = 6;
 var PASSWORD_MAX = 128;
-var gatePasswordSchema = z15.string().min(PASSWORD_MIN, `Password must be at least ${PASSWORD_MIN} characters.`).max(PASSWORD_MAX, `Password must be at most ${PASSWORD_MAX} characters.`);
-var setProtectionSchema = z15.object({
+var gatePasswordSchema = z18.string().min(PASSWORD_MIN, `Password must be at least ${PASSWORD_MIN} characters.`).max(PASSWORD_MAX, `Password must be at most ${PASSWORD_MAX} characters.`);
+var setProtectionSchema = z18.object({
   password: gatePasswordSchema.nullable()
 });
-var protectionResponseSchema = z15.object({
-  protected: z15.boolean()
+var protectionResponseSchema = z18.object({
+  protected: z18.boolean()
 });
-var unlockSchema = z15.object({
-  password: z15.string().min(1).max(1024)
+var unlockSchema = z18.object({
+  password: z18.string().min(1).max(1024)
 });
-var unlockResponseSchema = z15.object({
-  unlocked: z15.literal(true)
+var unlockResponseSchema = z18.object({
+  unlocked: z18.literal(true)
 });
 
 // ../shared/src/report.ts
-import { z as z16 } from "zod";
-var reportRequestSchema = z16.object({
-  reason: z16.string().max(1e3).optional()
+import { z as z19 } from "zod";
+var reportRequestSchema = z19.object({
+  reason: z19.string().max(1e3).optional()
 });
-var reportResponseSchema = z16.object({
-  reported: z16.literal(true)
+var reportResponseSchema = z19.object({
+  reported: z19.literal(true)
 });
 
 // ../shared/src/reviewers.ts
-import { z as z17 } from "zod";
-var artifactReviewerSchema = z17.object({
-  avatarUrl: z17.string().nullable(),
-  displayName: z17.string(),
+import { z as z20 } from "zod";
+var artifactReviewerSchema = z20.object({
+  avatarUrl: z20.string().nullable(),
+  displayName: z20.string(),
   // Exactly one of userId/guestId is set, per `kind`.
-  guestId: z17.string().nullable(),
+  guestId: z20.string().nullable(),
   // "account", not commentAuthorSchema's "member" — the whole point here is
   // that these people need not be workspace members. A guest can be named in
   // a comment but never notified: guest_identities carries a display name and
   // no email, so there is nowhere to send anything.
-  kind: z17.enum(["account", "guest"]),
-  userId: z17.string().nullable()
+  kind: z20.enum(["account", "guest"]),
+  userId: z20.string().nullable()
 });
-var artifactReviewerListResponseSchema = z17.object({
-  reviewers: z17.array(artifactReviewerSchema)
+var artifactReviewerListResponseSchema = z20.object({
+  reviewers: z20.array(artifactReviewerSchema)
 });
 
 // ../shared/src/stats.ts
-import { z as z18 } from "zod";
-var avgViewSecondsSchema = z18.number().int().nonnegative().nullable();
-var versionViewStatsSchema = z18.object({
+import { z as z21 } from "zod";
+var avgViewSecondsSchema = z21.number().int().nonnegative().nullable();
+var versionViewStatsSchema = z21.object({
   avgViewSeconds: avgViewSecondsSchema,
   // Views from inside the review shell's iframe vs. direct visits to
   // the render URL. views = embeddedViews + directViews.
-  directViews: z18.number().int().nonnegative(),
-  embeddedViews: z18.number().int().nonnegative(),
+  directViews: z21.number().int().nonnegative(),
+  embeddedViews: z21.number().int().nonnegative(),
   // Distinct hashed viewer IPs across the version's lifetime.
-  uniqueViewers: z18.number().int().nonnegative(),
-  versionNumber: z18.number().int().positive(),
-  views: z18.number().int().nonnegative()
+  uniqueViewers: z21.number().int().nonnegative(),
+  versionNumber: z21.number().int().positive(),
+  views: z21.number().int().nonnegative()
 });
-var dailyViewsSchema = z18.object({
+var dailyViewsSchema = z21.object({
   avgViewSeconds: avgViewSecondsSchema,
   // UTC day, YYYY-MM-DD.
-  day: z18.string(),
-  uniqueViewers: z18.number().int().nonnegative(),
-  views: z18.number().int().nonnegative()
+  day: z21.string(),
+  uniqueViewers: z21.number().int().nonnegative(),
+  views: z21.number().int().nonnegative()
 });
-var artifactStatsResponseSchema = z18.object({
+var artifactStatsResponseSchema = z21.object({
   avgViewSeconds: avgViewSecondsSchema,
-  daily: z18.array(dailyViewsSchema),
+  daily: z21.array(dailyViewsSchema),
   // Distinct hashed viewer IPs across all versions and days.
-  totalUniqueViewers: z18.number().int().nonnegative(),
-  totalViews: z18.number().int().nonnegative(),
-  versions: z18.array(versionViewStatsSchema)
+  totalUniqueViewers: z21.number().int().nonnegative(),
+  totalViews: z21.number().int().nonnegative(),
+  versions: z21.array(versionViewStatsSchema)
 });
 
 // ../shared/src/versions.ts
-import { z as z19 } from "zod";
-var versionSourceSchema = z19.object({
-  agentName: z19.string().nullable(),
-  type: z19.string()
+import { z as z22 } from "zod";
+var versionSourceSchema = z22.object({
+  agentName: z22.string().nullable(),
+  type: z22.string()
 });
-var versionChangesSchema = z19.object({
-  added: z19.array(z19.string()),
-  changed: z19.array(z19.string()),
-  removed: z19.array(z19.string())
+var versionChangesSchema = z22.object({
+  added: z22.array(z22.string()),
+  changed: z22.array(z22.string()),
+  removed: z22.array(z22.string())
 });
-var versionSummarySchema = z19.object({
+var versionSummarySchema = z22.object({
   // Absent for the first version — there is no previous version to diff against.
   changes: versionChangesSchema.nullable(),
-  createdAt: z19.string(),
-  entryUrl: z19.string().url(),
-  fileCount: z19.number().int().nonnegative(),
-  id: z19.string(),
-  isCurrent: z19.boolean(),
+  createdAt: z22.string(),
+  entryUrl: z22.string().url(),
+  fileCount: z22.number().int().nonnegative(),
+  id: z22.string(),
+  isCurrent: z22.boolean(),
   // Author-supplied bullet-point changelog; null when the publish omitted it.
-  notes: z19.string().nullable(),
+  notes: z22.string().nullable(),
   // The account that published this version, with their own avatar where
   // they've set one. Any workspace member can publish a new version
   // (SPEC-2 §5.1), so "which teammate" outranks "which agent" — the agent
   // is the tool, this is the person. Null for token-only publishes, which
   // carry no account.
-  publishedBy: z19.object({ image: z19.string().nullable(), name: z19.string() }).nullable(),
+  publishedBy: z22.object({ image: z22.string().nullable(), name: z22.string() }).nullable(),
   source: versionSourceSchema,
-  totalSizeBytes: z19.number().int().nonnegative(),
-  versionNumber: z19.number().int().positive()
+  totalSizeBytes: z22.number().int().nonnegative(),
+  versionNumber: z22.number().int().positive()
 });
-var versionListResponseSchema = z19.object({
-  versions: z19.array(versionSummarySchema)
+var versionListResponseSchema = z22.object({
+  versions: z22.array(versionSummarySchema)
 });
 
 // src/agent-identity.ts
@@ -1120,6 +1500,13 @@ function createApiClient(apiUrl2, publishToken) {
         (d) => agentHeartbeatResponseSchema.parse(d)
       );
     },
+    async clearData(artifactId, collection) {
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/data/${encodeURIComponent(collection)}`,
+        { headers, method: "DELETE" },
+        (d) => dataClearResponseSchema.parse(d)
+      );
+    },
     // SPEC-2 §6.3 — create a folder in a workspace. Account key required
     // (owner/admin; in a personal workspace that's always the user).
     async createFolder(workspaceId, body) {
@@ -1202,6 +1589,28 @@ function createApiClient(apiUrl2, publishToken) {
         (d) => artifactResponseSchema.parse(d)
       );
     },
+    async getDataSummary(artifactId) {
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/data`,
+        { headers, method: "GET" },
+        (d) => dataSummaryResponseSchema.parse(d)
+      );
+    },
+    async insertData(artifactId, collection, fields) {
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/data/${encodeURIComponent(collection)}`,
+        { body: JSON.stringify(fields), headers, method: "POST" },
+        (d) => dataRecordResponseSchema.parse(d).record
+      );
+    },
+    /** Owner-plane batch: up to DATA_LIMITS.maxInsertBatch, all-or-nothing. */
+    async insertDataBatch(artifactId, collection, records) {
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/data/${encodeURIComponent(collection)}`,
+        { body: JSON.stringify(records), headers, method: "POST" },
+        (d) => dataBatchInsertResponseSchema.parse(d)
+      );
+    },
     // SPEC §6.18 — everything owned by the account this client's API
     // key (or session) belongs to.
     async listArtifacts() {
@@ -1211,6 +1620,21 @@ function createApiClient(apiUrl2, publishToken) {
         (d) => artifactListResponseSchema.parse(d)
       );
     },
+    async listData(artifactId, collection, query = {}) {
+      const params = new URLSearchParams();
+      if (query.limit !== void 0) {
+        params.set("limit", String(query.limit));
+      }
+      if (query.cursor !== void 0) {
+        params.set("cursor", query.cursor);
+      }
+      const qs = params.toString();
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/data/${encodeURIComponent(collection)}${qs ? `?${qs}` : ""}`,
+        { headers, method: "GET" },
+        (d) => dataListResponseSchema.parse(d)
+      );
+    },
     async listFolders(workspaceId) {
       return request(
         `${base}/api/v1/workspaces/${workspaceId}/folders`,
@@ -1290,6 +1714,13 @@ function createApiClient(apiUrl2, publishToken) {
         () => void 0
       );
     },
+    async setExpiration(artifactId, expiresInSeconds) {
+      return request(
+        `${base}/api/v1/artifacts/${artifactId}/expiration`,
+        { body: JSON.stringify({ expiresInSeconds }), headers, method: "PUT" },
+        (d) => expirationResponseSchema.parse(d)
+      );
+    },
     // SPEC §6.16 — set a password (string) or clear it (null). Authorized
     // by the publish token this client was created with.
     async setProtection(artifactId, password) {
@@ -1346,17 +1777,17 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import path2 from "path";
-import { z as z21 } from "zod";
+import { z as z24 } from "zod";
 
 // src/credentials.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import path from "path";
-import { z as z20 } from "zod";
+import { z as z23 } from "zod";
 var DEFAULT_API_URL = "https://artifact.cafe";
-var credentialsSchema = z20.object({
-  keys: z20.record(z20.string(), z20.string()),
-  version: z20.literal(1)
+var credentialsSchema = z23.object({
+  keys: z23.record(z23.string(), z23.string()),
+  version: z23.literal(1)
 });
 function credentialsPath() {
   return path.join(homedir(), ".artifactcafe", "credentials");
@@ -1406,24 +1837,24 @@ function resolveApiKey(apiUrl2, flag) {
 }
 
 // src/config.ts
-var configSchema = z21.object({
-  apiUrl: z21.string(),
-  artifactId: z21.string(),
-  folder: z21.string().optional(),
-  folderId: z21.string().optional(),
+var configSchema = z24.object({
+  apiUrl: z24.string(),
+  artifactId: z24.string(),
+  folder: z24.string().optional(),
+  folderId: z24.string().optional(),
   // Optional: a folder linked by `link` to an artifact you own carries no
   // token — owner actions authorize via your stored login instead. A first
   // publish still writes the anonymous-mode token here.
-  publishToken: z21.string().optional(),
-  slug: z21.string(),
-  url: z21.string(),
-  workspace: z21.string().optional(),
-  workspaceId: z21.string().optional(),
-  workspaceKind: z21.enum(["personal", "workspace"]).optional()
-});
-var projectConfigSchema = z21.object({
-  folder: z21.string().trim().min(1).optional(),
-  workspace: z21.string().trim().min(1)
+  publishToken: z24.string().optional(),
+  slug: z24.string(),
+  url: z24.string(),
+  workspace: z24.string().optional(),
+  workspaceId: z24.string().optional(),
+  workspaceKind: z24.enum(["personal", "workspace"]).optional()
+});
+var projectConfigSchema = z24.object({
+  folder: z24.string().trim().min(1).optional(),
+  workspace: z24.string().trim().min(1)
 }).strict();
 var CONFIG_DIR = ".artifactcafe";
 var CONFIG_FILE = "config.json";
@@ -1459,7 +1890,7 @@ function readProjectConfig(dir) {
           JSON.parse(readFileSync2(file, "utf8"))
         );
       } catch (error) {
-        const message = error instanceof z21.ZodError ? error.issues[0]?.message ?? "invalid project target" : "invalid JSON";
+        const message = error instanceof z24.ZodError ? error.issues[0]?.message ?? "invalid project target" : "invalid JSON";
         throw new Error(`Invalid ${file}: ${message}.`);
       }
     }
@@ -1669,27 +2100,27 @@ async function comments(opts) {
     });
     return;
   }
-  const data = await client.exportComments(target.artifactId, {
+  const data2 = await client.exportComments(target.artifactId, {
     status: status2,
     version
   });
   if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data2, null, 2));
     return;
   }
-  printHuman(data, url, status2, version);
+  printHuman(data2, url, status2, version);
 }
 async function deriveReviewUrl(client, target) {
   const artifact = await client.getArtifact(target.artifactId);
   return reviewUrl(target.apiUrl, artifact.slug);
 }
 var sleep = (s) => new Promise((r) => setTimeout(r, s * 1e3));
-function messageCounts(data) {
-  return new Map(data.comments.map((t) => [t.id, 1 + t.replies.length]));
+function messageCounts(data2) {
+  return new Map(data2.comments.map((t) => [t.id, 1 + t.replies.length]));
 }
-function diffThreads(baseline, data) {
+function diffThreads(baseline, data2) {
   const changed = [];
-  for (const t of data.comments) {
+  for (const t of data2.comments) {
     const before = baseline.get(t.id);
     if (before === void 0) {
       changed.push({ ...t, change: "new" });
@@ -1732,8 +2163,8 @@ async function waitForFeedback(client, config, opts) {
   while (Date.now() < deadline) {
     await sleep(Math.min(pollSeconds(), (deadline - Date.now()) / 1e3));
     await heartbeat();
-    const data = await client.exportComments(config.artifactId, query);
-    if (diffThreads(baseline, data).length === 0) {
+    const data2 = await client.exportComments(config.artifactId, query);
+    if (diffThreads(baseline, data2).length === 0) {
       continue;
     }
     await sleep(settleSeconds());
@@ -1766,7 +2197,7 @@ async function waitForFeedback(client, config, opts) {
   }
   process.exit(WAIT_TIMEOUT_EXIT);
 }
-function printWaitResult(config, data, changed, json) {
+function printWaitResult(config, data2, changed, json) {
   if (json) {
     console.log(
       JSON.stringify(
@@ -1774,7 +2205,7 @@ function printWaitResult(config, data, changed, json) {
           artifactId: config.artifactId,
           threads: changed,
           timedOut: false,
-          versionNumber: data.versionNumber
+          versionNumber: data2.versionNumber
         },
         null,
         2
@@ -1793,22 +2224,22 @@ ${changed.length} thread${plural} with new feedback \u2014 ${config.url}
     printThread(thread);
   }
 }
-function printHuman(data, url, status2, version) {
+function printHuman(data2, url, status2, version) {
   const statusLabel = status2 === "all" ? "" : `${status2} `;
   let scope = "across all versions";
   if (version === "current") {
-    scope = data.versionNumber === null ? "on the current version" : `on v${data.versionNumber}`;
+    scope = data2.versionNumber === null ? "on the current version" : `on v${data2.versionNumber}`;
   }
-  if (data.comments.length === 0) {
+  if (data2.comments.length === 0) {
     console.log(`No ${statusLabel}comments ${scope}.`);
     return;
   }
-  const plural = data.comments.length === 1 ? "" : "s";
+  const plural = data2.comments.length === 1 ? "" : "s";
   console.log(
-    `${data.comments.length} ${statusLabel}thread${plural} ${scope} \u2014 ${url}
+    `${data2.comments.length} ${statusLabel}thread${plural} ${scope} \u2014 ${url}
 `
   );
-  for (const thread of data.comments) {
+  for (const thread of data2.comments) {
     printThread(thread);
   }
 }
@@ -1853,18 +2284,230 @@ function indent(text, pad) {
 }
 
 // src/dashboard.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/publish.ts
 import { exec } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
-import path6 from "path";
+import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import path7 from "path";
 import { createInterface } from "readline";
 
+// src/data.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path5 from "path";
+function inspectDataManifest(files) {
+  const info = { announcements: [] };
+  const manifestFile = files.find((f) => f.path === DATA_MANIFEST_PATH);
+  if (manifestFile) {
+    const parsed = parseDataManifest(
+      readFileSync3(manifestFile.absPath, "utf8")
+    );
+    if (!parsed.ok) {
+      throw new Error(
+        `${DATA_MANIFEST_PATH} is invalid:
+${(parsed.errors ?? []).map((e) => `  - ${e}`).join("\n")}`
+      );
+    }
+    info.config = parsed.config;
+    for (const [name, collection] of Object.entries(
+      parsed.config?.collections ?? {}
+    )) {
+      const bits = [
+        `read: ${collection.access.read}`,
+        `insert: ${collection.access.insert}`
+      ];
+      if (collection.access.update !== "owner") {
+        bits.push(`update: ${collection.access.update}`);
+      }
+      if (collection.access.delete !== "owner") {
+        bits.push(`delete: ${collection.access.delete}`);
+      }
+      if (collection.rateLimit) {
+        bits.push(collection.rateLimit);
+      }
+      info.announcements.push(`\u26C1 Data enabled: ${name} (${bits.join(", ")})`);
+    }
+    if (info.announcements.length === 0) {
+      info.announcements.push(
+        "\u26C1 Data disabled (empty collections in .artifact/data.json)"
+      );
+    }
+  }
+  return info;
+}
+function requireLinkedArtifact(dir) {
+  const resolved = path5.resolve(dir);
+  const config = readConfig(resolved);
+  if (!config) {
+    throw new Error(
+      `No artifact linked in ${resolved} \u2014 run \`artifact-cafe publish\` there first (.artifactcafe/config.json not found).`
+    );
+  }
+  return {
+    apiUrl: process.env.ARTIFACT_CAFE_URL ?? config.apiUrl,
+    artifactId: config.artifactId,
+    publishToken: resolveApiKey(process.env.ARTIFACT_CAFE_URL ?? config.apiUrl) ?? config.publishToken ?? process.env.ARTIFACT_CAFE_TOKEN,
+    url: config.url
+  };
+}
+async function dataLs(opts) {
+  const linked = requireLinkedArtifact(opts.dir);
+  const client = createApiClient(linked.apiUrl, linked.publishToken);
+  const records = [];
+  let cursor;
+  do {
+    const page = await client.listData(linked.artifactId, opts.collection, {
+      cursor,
+      limit: 200
+    });
+    records.push(...page.records);
+    cursor = page.nextCursor ?? void 0;
+  } while (cursor && (opts.limit === void 0 || records.length < opts.limit));
+  const shown = opts.limit === void 0 ? records : records.slice(0, opts.limit);
+  if (opts.json) {
+    console.log(
+      JSON.stringify({ collection: opts.collection, records: shown }, null, 2)
+    );
+    return;
+  }
+  if (shown.length === 0) {
+    console.log(`No records in "${opts.collection}".`);
+    return;
+  }
+  const plural = shown.length === 1 ? "" : "s";
+  console.log(
+    `${shown.length} record${plural} in "${opts.collection}" \u2014 ${linked.url}
+`
+  );
+  for (const record of shown) {
+    const { created_at, created_by, id, updated_at: _u, ...fields } = record;
+    const author = created_by ?? "anonymous";
+    console.log(`\u25CF ${id} \xB7 ${String(created_at).slice(0, 10)} \xB7 ${author}`);
+    console.log(`  ${JSON.stringify(fields)}`);
+  }
+}
+var RECORD_SHAPE_HINT = `a JSON object or array of objects, e.g. '{"name":"Ada"}'`;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function dataInsert(opts) {
+  if (opts.record === void 0 === (opts.file === void 0)) {
+    throw new Error("Pass exactly one of --record '<json>' or --file <path>.");
+  }
+  const text = opts.record ?? readFileSync3(opts.file, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`Records must be ${RECORD_SHAPE_HINT}.`);
+  }
+  const linked = requireLinkedArtifact(opts.dir);
+  const client = createApiClient(linked.apiUrl, linked.publishToken);
+  if (isRecord(parsed)) {
+    const record = await client.insertData(
+      linked.artifactId,
+      opts.collection,
+      parsed
+    );
+    if (opts.json) {
+      console.log(JSON.stringify({ collection: opts.collection, record }));
+      return;
+    }
+    console.log(`Inserted ${record.id} into "${opts.collection}".`);
+    return;
+  }
+  if (!(Array.isArray(parsed) && parsed.length > 0 && parsed.every(isRecord))) {
+    throw new Error(`Records must be ${RECORD_SHAPE_HINT}.`);
+  }
+  const records = [];
+  for (let i = 0; i < parsed.length; i += DATA_LIMITS.maxInsertBatch) {
+    try {
+      const page = await client.insertDataBatch(
+        linked.artifactId,
+        opts.collection,
+        parsed.slice(i, i + DATA_LIMITS.maxInsertBatch)
+      );
+      records.push(...page.records);
+    } catch (err) {
+      if (records.length === 0) {
+        throw err;
+      }
+      const note = ` (the first ${records.length} records were inserted; records ${i}+ may not have been)`;
+      if (err instanceof ApiRequestError) {
+        throw new ApiRequestError(
+          err.status,
+          err.code,
+          `${err.message}${note}`,
+          err.retryAfter
+        );
+      }
+      throw new Error(
+        `${err instanceof Error ? err.message : String(err)}${note}`
+      );
+    }
+  }
+  if (opts.json) {
+    console.log(JSON.stringify({ collection: opts.collection, records }));
+    return;
+  }
+  const plural = records.length === 1 ? "" : "s";
+  console.log(
+    `Inserted ${records.length} record${plural} into "${opts.collection}".`
+  );
+}
+async function dataExport(opts) {
+  const linked = requireLinkedArtifact(opts.dir);
+  const client = createApiClient(linked.apiUrl, linked.publishToken);
+  const summary = await client.getDataSummary(linked.artifactId);
+  const collections = {};
+  for (const { name } of summary.collections) {
+    const records = [];
+    let cursor;
+    do {
+      const page = await client.listData(linked.artifactId, name, {
+        cursor,
+        limit: 200
+      });
+      records.push(...page.records);
+      cursor = page.nextCursor ?? void 0;
+    } while (cursor);
+    collections[name] = records;
+  }
+  console.log(
+    JSON.stringify(
+      {
+        artifactId: linked.artifactId,
+        collections,
+        enabled: summary.enabled,
+        url: linked.url
+      },
+      null,
+      2
+    )
+  );
+}
+async function dataClear(opts) {
+  if (!opts.yes) {
+    throw new Error(
+      `Clearing "${opts.collection}" deletes every record in it. Re-run with --yes to confirm.`
+    );
+  }
+  const linked = requireLinkedArtifact(opts.dir);
+  const client = createApiClient(linked.apiUrl, linked.publishToken);
+  const result = await client.clearData(linked.artifactId, opts.collection);
+  if (opts.json) {
+    console.log(
+      JSON.stringify({ cleared: result.cleared, collection: opts.collection })
+    );
+    return;
+  }
+  console.log(`Cleared ${result.cleared} record(s) from "${opts.collection}".`);
+}
+
 // src/manifest.ts
 import { createHash } from "crypto";
-import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
-import path5 from "path";
+import { lstatSync, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
+import path6 from "path";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".artifactcafe"]);
 var IGNORED_FILES = /* @__PURE__ */ new Set([".DS_Store", "artifact-cafe.json"]);
 function isIgnoredFile(name) {
@@ -1885,6 +2528,7 @@ function isIgnoredFile(name) {
 var MIME_TYPES = {
   ".avif": "image/avif",
   ".css": "text/css",
+  ".csv": "text/csv",
   ".gif": "image/gif",
   ".htm": "text/html",
   ".html": "text/html",
@@ -1894,6 +2538,7 @@ var MIME_TYPES = {
   ".js": "text/javascript",
   ".json": "application/json",
   ".map": "application/json",
+  ".markdown": "text/markdown",
   ".md": "text/markdown",
   ".mjs": "text/javascript",
   ".mp3": "audio/mpeg",
@@ -1913,7 +2558,32 @@ var MIME_TYPES = {
   ".xml": "application/xml"
 };
 function mimeFor(filePath) {
-  return MIME_TYPES[path5.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+  return MIME_TYPES[path6.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function localFile(absPath, rel) {
+  if (isIgnoredFile(path6.basename(rel)) || !isSafeArtifactPath(rel)) {
+    return null;
+  }
+  const { size } = statSync(absPath);
+  if (size === 0) {
+    return null;
+  }
+  return {
+    absPath,
+    hash: `sha256_${createHash("sha256").update(readFileSync4(absPath)).digest("hex")}`,
+    mimeType: mimeFor(rel),
+    path: rel,
+    size
+  };
+}
+function scanPath(target) {
+  const stat = lstatSync(target);
+  if (stat.isDirectory()) {
+    return scanDirectory(target);
+  }
+  const rel = path6.basename(target);
+  const file = stat.isFile() ? localFile(target, rel) : null;
+  return file ? { files: [file], skipped: [] } : { files: [], skipped: [rel] };
 }
 function scanDirectory(dir) {
   const files = [];
@@ -1921,7 +2591,7 @@ function scanDirectory(dir) {
   function walk(current, relPrefix) {
     for (const entry of readdirSync(current, { withFileTypes: true })) {
       const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
-      const abs = path5.join(current, entry.name);
+      const abs = path6.join(current, entry.name);
       if (entry.isSymbolicLink()) {
         skipped.push(rel);
         continue;
@@ -1937,23 +2607,12 @@ function scanDirectory(dir) {
       if (!entry.isFile()) {
         continue;
       }
-      if (isIgnoredFile(entry.name) || !isSafeArtifactPath(rel)) {
+      const file = localFile(abs, rel);
+      if (!file) {
         skipped.push(rel);
         continue;
       }
-      const { size } = statSync(abs);
-      if (size === 0) {
-        skipped.push(rel);
-        continue;
-      }
-      const content = readFileSync3(abs);
-      files.push({
-        absPath: abs,
-        hash: `sha256_${createHash("sha256").update(content).digest("hex")}`,
-        mimeType: mimeFor(rel),
-        path: rel,
-        size
-      });
+      files.push(file);
     }
   }
   walk(dir, "");
@@ -1961,27 +2620,37 @@ function scanDirectory(dir) {
   return { files, skipped };
 }
 function resolveEntry(files, explicit) {
-  if (explicit) {
-    if (!files.some((f) => f.path === explicit)) {
-      throw new Error(
-        `Entry file "${explicit}" not found in the publish folder.`
-      );
+  return resolvePublishEntry(files, explicit);
+}
+
+// src/spinner.ts
+var FRAMES = ["\xE3", "\xE4", "\xE5"];
+var INTERVAL_MS = 420;
+var AMBER2 = "\x1B[38;2;214;138;57m";
+var RESET2 = "\x1B[0m";
+var CLEAR_LINE = "\r\x1B[2K";
+function startBrewing(label, enabled) {
+  const stream = process.stderr;
+  if (!(enabled && stream.isTTY) || process.env.CI) {
+    return { stop: () => void 0 };
+  }
+  const color = !process.env.NO_COLOR;
+  let frame = 0;
+  const draw = () => {
+    const glyph = FRAMES[frame % FRAMES.length];
+    stream.write(
+      `${CLEAR_LINE}  ${color ? `${AMBER2}${glyph}${RESET2}` : glyph} ${label}`
+    );
+    frame += 1;
+  };
+  draw();
+  const timer = setInterval(draw, INTERVAL_MS);
+  return {
+    stop() {
+      clearInterval(timer);
+      stream.write(CLEAR_LINE);
     }
-    return explicit;
-  }
-  if (files.some((f) => f.path === "index.html")) {
-    return "index.html";
-  }
-  const htmlFiles = files.filter(
-    (f) => f.path.endsWith(".html") && !f.path.includes("/")
-  );
-  const [onlyHtmlFile] = htmlFiles;
-  if (onlyHtmlFile && htmlFiles.length === 1) {
-    return onlyHtmlFile.path;
-  }
-  throw new Error(
-    htmlFiles.length === 0 ? "No entry file found. Add an index.html or pass --entry <file>." : `Multiple HTML files found (${htmlFiles.map((f) => f.path).join(", ")}). Pass --entry <file>.`
-  );
+  };
 }
 
 // src/publish.ts
@@ -1992,8 +2661,10 @@ var REVIEW_LABEL = {
   readonly: "read-only \u2014 existing comments only"
 };
 async function publish(opts) {
-  const dir = path6.resolve(opts.dir);
+  const target = path7.resolve(opts.dir);
+  const dir = statSync2(target).isFile() ? path7.dirname(target) : target;
   const config = readConfig(dir);
+  const expiresInSeconds = opts.expiresIn === void 0 ? void 0 : parseArtifactDuration(opts.expiresIn);
   if (opts.password !== void 0) {
     const parsed = gatePasswordSchema.safeParse(opts.password);
     if (!parsed.success) {
@@ -2018,13 +2689,14 @@ async function publish(opts) {
     apiUrl: apiUrl2,
     config,
     isNewArtifact: artifactId === null,
-    opts
+    opts: { ...opts, dir }
   });
-  const { files, skipped } = scanDirectory(dir);
+  const { files, skipped } = scanPath(target);
   if (files.length === 0) {
-    throw new Error(`Nothing to publish in ${dir} (after ignore rules).`);
+    throw new Error(`Nothing to publish at ${target} (after ignore rules).`);
   }
   const entryPath = resolveEntry(files, opts.entry);
+  const dataInfo = inspectDataManifest(files);
   const log = (msg) => {
     if (!opts.json) {
       console.log(msg);
@@ -2035,6 +2707,7 @@ async function publish(opts) {
   }
   const sessionBody = {
     artifactId,
+    ...expiresInSeconds === void 0 ? {} : { expiresInSeconds },
     // Overrides the entry HTML's own meta description on the share card.
     // Omitted entirely when absent, so the document keeps speaking for itself.
     ...opts.description?.trim() ? { description: opts.description.trim() } : {},
@@ -2069,11 +2742,17 @@ async function publish(opts) {
     client = createApiClient(apiUrl2, credential);
     session = await client.createSession(sessionBody);
   }
+  if (expiresInSeconds !== void 0 && session.expiresInSeconds !== expiresInSeconds) {
+    throw new Error(
+      "This API does not support temporary publishing. Nothing was uploaded or finalized; upgrade the API before using --expires-in."
+    );
+  }
   const byPath = new Map(files.map((f) => [f.path, f]));
   log(
     `  uploading ${session.filesToUpload.length} file(s)` + (session.skippedFiles.length ? `, ${session.skippedFiles.length} unchanged` : "")
   );
   const presence = startPublishingPresence(client, session.artifactId);
+  const brewing = startBrewing("brewing\u2026", !opts.json);
   try {
     await inBatches(
       session.filesToUpload,
@@ -2085,15 +2764,23 @@ async function publish(opts) {
         }
         await uploadFile(
           upload.uploadUrl,
-          readFileSync4(file.absPath),
+          readFileSync5(file.absPath),
           file.mimeType
         );
       }
     );
+  } catch (error) {
+    brewing.stop();
+    throw error;
   } finally {
     presence.stop();
   }
-  const result = await client.finalize(session.publishSessionId);
+  let result;
+  try {
+    result = await client.finalize(session.publishSessionId);
+  } finally {
+    brewing.stop();
+  }
   if (usingAgentToken && result.workspaceId) {
     placement.workspaceId = result.workspaceId;
   }
@@ -2133,6 +2820,9 @@ async function publish(opts) {
       JSON.stringify(
         {
           artifactId: result.artifactId,
+          autoDeleteAt: result.autoDeleteAt ?? null,
+          expiresAt: result.expiresAt ?? null,
+          ...dataInfo.config ? { data: dataInfo.config } : {},
           claimed: result.claimed,
           destination: placement.destination,
           destinationSource: placement.destinationSource,
@@ -2176,7 +2866,7 @@ ${result.url}
 ${result.claimUrl}
 `
       );
-    } else if (result.claimed) {
+    } else if (result.claimed && !result.expiresAt) {
       console.log("Claimed by your account \u2014 no expiry.\n");
     }
     if (opts.password !== void 0) {
@@ -2211,6 +2901,17 @@ ${result.claimUrl}
 `);
     }
   }
+  if (!opts.json) {
+    if (result.expiresAt) {
+      console.log(
+        `${result.autoDeleteAt ? "Temporary artifact" : "Anonymous artifact"} \u2014 expires at ${result.expiresAt}. All versions, comments, files, and artifact data will be automatically deleted.
+`
+      );
+    }
+    for (const announcement of dataInfo.announcements) {
+      console.log(announcement);
+    }
+  }
   if (opts.open && !opts.json && process.stdout.isTTY) {
     openInBrowser(result.url);
   }
@@ -2280,9 +2981,9 @@ async function resolvePlacement(params) {
       };
     }
     if (shouldPromptForWorkspace(opts)) {
-      const data2 = await createApiClient(apiUrl2, apiKey).listWorkspaces();
-      if (data2.workspaces.length > 1) {
-        const choice = await pickWorkspace(data2.workspaces);
+      const data3 = await createApiClient(apiUrl2, apiKey).listWorkspaces();
+      if (data3.workspaces.length > 1) {
+        const choice = await pickWorkspace(data3.workspaces);
         return {
           destination: choice.workspace.isPersonal ? "personal" : "workspace",
           destinationLabel: choice.workspace.isPersonal ? "Personal" : choice.workspace.name,
@@ -2308,19 +3009,19 @@ async function resolvePlacement(params) {
     throw new Error("--folder requires --workspace or a stored workspace.");
   }
   const client = createApiClient(apiUrl2, apiKey);
-  const data = await client.listWorkspaces();
+  const data2 = await client.listWorkspaces();
   const workspaceHandle = opts.workspace ?? config?.workspace ?? projectConfig?.workspace;
   let workspace;
   if (workspaceHandle) {
-    workspace = data.workspaces.find(
+    workspace = data2.workspaces.find(
       (candidate) => candidate.handle === workspaceHandle
     );
   } else if (config?.workspaceId) {
-    workspace = data.workspaces.find(
+    workspace = data2.workspaces.find(
       (candidate) => candidate.id === config.workspaceId
     );
   } else {
-    workspace = data.workspaces.find((candidate) => candidate.isPersonal);
+    workspace = data2.workspaces.find((candidate) => candidate.isPersonal);
   }
   if (!workspace) {
     const target = workspaceHandle ? `workspace with handle "${workspaceHandle}"` : "personal workspace";
@@ -2458,7 +3159,7 @@ function openInBrowser(url) {
 
 // src/dashboard.ts
 function openDashboard(opts) {
-  const base = process.env.ARTIFACT_CAFE_URL ?? readConfig(path7.resolve(opts.dir))?.apiUrl ?? DEFAULT_API_URL;
+  const base = process.env.ARTIFACT_CAFE_URL ?? readConfig(path8.resolve(opts.dir))?.apiUrl ?? DEFAULT_API_URL;
   const url = `${base.replace(/\/$/, "")}/dashboard`;
   console.log(url);
   if (process.stdout.isTTY) {
@@ -2500,6 +3201,35 @@ function printCliError(err, json) {
   }
 }
 
+// src/expiration.ts
+import path9 from "path";
+async function expiration(opts) {
+  if (opts.duration !== void 0 === opts.keep) {
+    throw new Error("Provide exactly one of --in <duration> or --keep.");
+  }
+  const seconds = opts.keep ? null : parseArtifactDuration(opts.duration);
+  const target = resolveArtifactTarget(path9.resolve(opts.dir), opts);
+  const result = await createApiClient(
+    target.apiUrl,
+    target.credential
+  ).setExpiration(target.artifactId, seconds);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.autoDeleteAt) {
+    console.log(`Temporary artifact \u2014 expires at ${result.expiresAt}.`);
+  } else if (result.expiresAt) {
+    console.log(
+      `Temporary deadline cleared. Anonymous retention still expires at ${result.expiresAt}; claim the artifact to keep it.`
+    );
+  } else {
+    console.log(
+      "Artifact kept \u2014 no automatic expiry. Its link, versions, and comments are preserved."
+    );
+  }
+}
+
 // src/folders.ts
 async function folders(opts) {
   if (opts.action !== void 0 && opts.action !== "create") {
@@ -2544,21 +3274,21 @@ async function folders(opts) {
     await createFolder(client, workspace, opts);
     return;
   }
-  const data = await client.listFolders(workspace.id);
+  const data2 = await client.listFolders(workspace.id);
   if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data2, null, 2));
     return;
   }
-  if (data.folders.length === 0) {
+  if (data2.folders.length === 0) {
     console.log(`No folders in workspace ${workspace.handle}.`);
     return;
   }
-  const plural = data.folders.length === 1 ? "" : "s";
+  const plural = data2.folders.length === 1 ? "" : "s";
   console.log(
-    `${data.folders.length} folder${plural} in ${workspace.handle}
+    `${data2.folders.length} folder${plural} in ${workspace.handle}
 `
   );
-  for (const folder of data.folders) {
+  for (const folder of data2.folders) {
     printFolder(folder);
   }
 }
@@ -2596,7 +3326,7 @@ function printFolder(folder) {
 }
 
 // src/link.ts
-import path8 from "path";
+import path10 from "path";
 import { createInterface as createInterface2 } from "readline";
 
 // src/list.ts
@@ -2653,28 +3383,28 @@ async function list(opts) {
     await listWorkspace(client, opts);
     return;
   }
-  const [data, groups] = await Promise.all([
+  const [data2, groups] = await Promise.all([
     client.listArtifacts(),
     teamGroups(client)
   ]);
   if (opts.json) {
     console.log(
-      JSON.stringify({ artifacts: data.artifacts, workspaces: groups }, null, 2)
+      JSON.stringify({ artifacts: data2.artifacts, workspaces: groups }, null, 2)
     );
     return;
   }
-  const total = data.artifacts.length + groups.reduce((sum, group) => sum + group.artifacts.length, 0);
+  const total = data2.artifacts.length + groups.reduce((sum, group) => sum + group.artifacts.length, 0);
   if (total === 0) {
     console.log(
       "No artifacts you can publish to yet \u2014 publish while logged in, or claim one via its claim link."
     );
     return;
   }
-  if (data.artifacts.length > 0) {
-    const plural = data.artifacts.length === 1 ? "" : "s";
-    console.log(`${data.artifacts.length} artifact${plural}
+  if (data2.artifacts.length > 0) {
+    const plural = data2.artifacts.length === 1 ? "" : "s";
+    console.log(`${data2.artifacts.length} artifact${plural}
 `);
-    for (const artifact of data.artifacts) {
+    for (const artifact of data2.artifacts) {
       printArtifact(artifact);
     }
   }
@@ -2825,7 +3555,7 @@ async function link(opts) {
     }
     chosen = await pickArtifact(artifacts);
   }
-  const dir = path8.resolve(opts.dir);
+  const dir = path10.resolve(opts.dir);
   writeConfig(dir, {
     apiUrl: apiUrl2,
     artifactId: chosen.id,
@@ -2993,7 +3723,7 @@ function logout(opts) {
 }
 
 // src/message.ts
-import path9 from "path";
+import path11 from "path";
 async function readStdin2() {
   if (process.stdin.isTTY) {
     return "";
@@ -3017,7 +3747,7 @@ async function editMessage(opts) {
       'Nothing to save. Pass the new text with --body "\u2026", or pipe it on stdin.'
     );
   }
-  const dir = path9.resolve(opts.dir);
+  const dir = path11.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3037,7 +3767,7 @@ async function deleteMessage(opts) {
       "Pass the message id to delete \u2014 get it from `artifact-cafe comments --json`."
     );
   }
-  const dir = path9.resolve(opts.dir);
+  const dir = path11.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3052,12 +3782,12 @@ async function deleteMessage(opts) {
 }
 
 // src/move.ts
-import path10 from "path";
+import path12 from "path";
 async function move(opts) {
   if (Boolean(opts.folder) === Boolean(opts.unfiled)) {
     throw new Error("Pass exactly one of --folder <name-or-id> or --unfiled.");
   }
-  const dir = path10.resolve(opts.dir);
+  const dir = path12.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3078,8 +3808,8 @@ async function move(opts) {
   let folderId = null;
   let folderName = null;
   if (opts.folder) {
-    const data = await client.listFolders(artifact.workspaceId);
-    const matches = data.folders.filter(
+    const data2 = await client.listFolders(artifact.workspaceId);
+    const matches = data2.folders.filter(
       (candidate) => candidate.name === opts.folder || candidate.id === opts.folder
     );
     if (matches.length === 0) {
@@ -3147,9 +3877,9 @@ async function move(opts) {
 }
 
 // src/open.ts
-import path11 from "path";
+import path13 from "path";
 async function openArtifact(opts) {
-  const dir = path11.resolve(opts.dir);
+  const dir = path13.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3167,7 +3897,7 @@ async function openArtifact(opts) {
 }
 
 // src/protect.ts
-import path12 from "path";
+import path14 from "path";
 async function protect(opts) {
   if (opts.off && opts.password !== void 0) {
     throw new Error("Pass either --password or --off, not both.");
@@ -3184,7 +3914,7 @@ async function protect(opts) {
       throw new Error(parsed.error.issues[0]?.message ?? "Invalid password.");
     }
   }
-  const dir = path12.resolve(opts.dir);
+  const dir = path14.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3209,7 +3939,7 @@ async function protect(opts) {
 }
 
 // src/reply.ts
-import path13 from "path";
+import path15 from "path";
 async function readStdin3() {
   if (process.stdin.isTTY) {
     return "";
@@ -3233,7 +3963,7 @@ async function replyToThread(opts) {
       'Nothing to post. Pass the reply with --body "\u2026", or pipe it on stdin.'
     );
   }
-  const dir = path13.resolve(opts.dir);
+  const dir = path15.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3262,7 +3992,7 @@ async function replyToThread(opts) {
 }
 
 // src/resolve.ts
-import path14 from "path";
+import path16 from "path";
 async function changeThreadStatus(opts) {
   const threadId = opts.thread?.trim();
   if (!threadId) {
@@ -3270,7 +4000,7 @@ async function changeThreadStatus(opts) {
       `Pass the thread id to ${opts.action} \u2014 get it from \`artifact-cafe comments --json\`.`
     );
   }
-  const dir = path14.resolve(opts.dir);
+  const dir = path16.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3307,7 +4037,7 @@ async function changeThreadStatus(opts) {
 }
 
 // src/review.ts
-import path15 from "path";
+import path17 from "path";
 var OUTCOME = {
   off: "Plain artifact \u2014 the review tools are hidden entirely",
   open: "Open for review \u2014 anyone who can open it can comment",
@@ -3321,7 +4051,7 @@ async function review(opts) {
     );
   }
   const mode = parsed.data;
-  const dir = path15.resolve(opts.dir);
+  const dir = path17.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3343,10 +4073,10 @@ async function review(opts) {
 }
 
 // src/share.ts
-import path16 from "path";
+import path18 from "path";
 var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 async function share(opts) {
-  const dir = path16.resolve(opts.dir);
+  const dir = path18.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3401,7 +4131,7 @@ General access: ${visibility}`);
   console.log("");
 }
 async function unshare(opts) {
-  const dir = path16.resolve(opts.dir);
+  const dir = path18.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3424,7 +4154,7 @@ async function unshare(opts) {
 }
 
 // src/status.ts
-import path17 from "path";
+import path19 from "path";
 async function status(opts) {
   if (!AGENT_STATES.includes(opts.state)) {
     throw new Error(
@@ -3432,7 +4162,7 @@ async function status(opts) {
     );
   }
   const state = opts.state;
-  const dir = path17.resolve(opts.dir);
+  const dir = path19.resolve(opts.dir);
   const target = resolveArtifactTarget(dir, {
     apiKey: opts.apiKey,
     artifact: opts.artifact
@@ -3458,40 +4188,40 @@ async function status(opts) {
 }
 
 // src/update.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir2 } from "os";
-import path18 from "path";
-import { z as z22 } from "zod";
+import path20 from "path";
+import { z as z25 } from "zod";
 var REGISTRY_LATEST_URL = "https://registry.npmjs.org/artifact-cafe/latest";
 var SKILL_SOURCE_URL = "https://raw.githubusercontent.com/Artifact-Cafe/skill/main/artifact-cafe/SKILL.md";
 var SKILL_UPDATE_COMMAND = "npx skills add artifact-cafe/skill --skill artifact-cafe -g";
 var CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 2e3;
 var SKILL_VERSION_PATTERN = /\*\*Skill version:\s*(\d+\.\d+\.\d+)\*\*/;
-var cacheSchema = z22.object({
-  checkedAt: z22.number(),
-  cliLatest: z22.string().nullable(),
-  skillLatest: z22.string().nullable(),
-  version: z22.literal(1)
+var cacheSchema = z25.object({
+  checkedAt: z25.number(),
+  cliLatest: z25.string().nullable(),
+  skillLatest: z25.string().nullable(),
+  version: z25.literal(1)
 });
 function cliVersion() {
   const pkg = createRequire(import.meta.url)("../package.json");
   return pkg.version;
 }
 function cachePath() {
-  return path18.join(homedir2(), ".artifactcafe", "update-check.json");
+  return path20.join(homedir2(), ".artifactcafe", "update-check.json");
 }
 function readCache() {
   try {
-    return cacheSchema.parse(JSON.parse(readFileSync5(cachePath(), "utf8")));
+    return cacheSchema.parse(JSON.parse(readFileSync6(cachePath(), "utf8")));
   } catch {
     return null;
   }
 }
 function writeCache(cache) {
   try {
-    mkdirSync3(path18.dirname(cachePath()), { mode: 448, recursive: true });
+    mkdirSync3(path20.dirname(cachePath()), { mode: 448, recursive: true });
     writeFileSync3(cachePath(), `${JSON.stringify(cache, null, 2)}
 `);
   } catch {
@@ -3528,7 +4258,7 @@ async function fetchText(url) {
 }
 async function fetchLatestVersions(previous) {
   const [cli, skill] = await Promise.all([
-    fetchJson(REGISTRY_LATEST_URL).then((body) => z22.object({ version: z22.string() }).parse(body).version).catch(() => null),
+    fetchJson(REGISTRY_LATEST_URL).then((body) => z25.object({ version: z25.string() }).parse(body).version).catch(() => null),
     fetchText(SKILL_SOURCE_URL).then((body) => SKILL_VERSION_PATTERN.exec(body)?.[1] ?? null).catch(() => null)
   ]);
   return {
@@ -3544,12 +4274,12 @@ function installedSkillVersions() {
   const versions = [];
   for (const root of roots) {
     for (const dir of dirs) {
-      const file = path18.join(root, dir, "skills", "artifact-cafe", "SKILL.md");
+      const file = path20.join(root, dir, "skills", "artifact-cafe", "SKILL.md");
       if (!existsSync3(file)) {
         continue;
       }
       try {
-        const found = SKILL_VERSION_PATTERN.exec(readFileSync5(file, "utf8"));
+        const found = SKILL_VERSION_PATTERN.exec(readFileSync6(file, "utf8"));
         if (found?.[1]) {
           versions.push(found[1]);
         }
@@ -3618,19 +4348,19 @@ async function workspaces(opts) {
       `Listing workspaces needs an account \u2014 run \`artifact-cafe login\` first (no API key for ${apiOrigin(apiUrl2)}).`
     );
   }
-  const data = await createApiClient(apiUrl2, key).listWorkspaces();
+  const data2 = await createApiClient(apiUrl2, key).listWorkspaces();
   if (opts.json) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify(data2, null, 2));
     return;
   }
-  if (data.workspaces.length === 0) {
+  if (data2.workspaces.length === 0) {
     console.log("No workspaces yet \u2014 create one from the dashboard.");
     return;
   }
-  const plural = data.workspaces.length === 1 ? "" : "s";
-  console.log(`${data.workspaces.length} workspace${plural}
+  const plural = data2.workspaces.length === 1 ? "" : "s";
+  console.log(`${data2.workspaces.length} workspace${plural}
 `);
-  for (const workspace of data.workspaces) {
+  for (const workspace of data2.workspaces) {
     printWorkspace(workspace);
   }
 }
@@ -3672,10 +4402,14 @@ var publish2 = defineCommand({
     },
     dir: {
       default: ".",
-      description: "Directory to publish",
+      description: "File or directory to publish",
       type: "positional"
     },
     entry: { description: "Entry file (default: auto-detect)", type: "string" },
+    "expires-in": {
+      description: "Temporary lifetime: 30m, 1h, 7d (ordinary republishes preserve it)",
+      type: "string"
+    },
     folder: {
       description: "Publish into this workspace folder name (or id)",
       type: "string"
@@ -3700,7 +4434,10 @@ var publish2 = defineCommand({
       type: "string"
     }
   },
-  meta: { description: "Publish a folder as an artifact", name: "publish" },
+  meta: {
+    description: "Publish a file or folder as an artifact",
+    name: "publish"
+  },
   async run({ args }) {
     try {
       await publish({
@@ -3709,6 +4446,7 @@ var publish2 = defineCommand({
         description: readStringArg(process.argv.slice(2), "--description"),
         dir: args.dir,
         entry: args.entry,
+        expiresIn: args["expires-in"],
         folder: args.folder,
         json: Boolean(args.json),
         notes: readStringArg(process.argv.slice(2), "--notes"),
@@ -3964,6 +4702,48 @@ var link2 = defineCommand({
     }
   }
 });
+var expiration2 = defineCommand({
+  args: {
+    "api-key": {
+      description: "Account or agent token (default: env or login)",
+      type: "string"
+    },
+    artifact: {
+      description: "Artifact ID instead of the linked folder",
+      type: "string"
+    },
+    dir: {
+      default: ".",
+      description: "Published directory",
+      type: "positional"
+    },
+    in: { description: "Reset lifetime from now: 30m, 1h, 7d", type: "string" },
+    json: { description: "Machine-readable output", type: "boolean" },
+    keep: {
+      description: "Clear the explicit temporary deadline",
+      type: "boolean"
+    }
+  },
+  meta: {
+    description: "Extend a temporary artifact or keep it",
+    name: "expiration"
+  },
+  async run({ args }) {
+    try {
+      await expiration({
+        apiKey: args["api-key"],
+        artifact: args.artifact,
+        dir: args.dir,
+        duration: args.in,
+        json: Boolean(args.json),
+        keep: Boolean(args.keep)
+      });
+    } catch (err) {
+      printCliError(err, Boolean(args.json));
+      process.exitCode = 1;
+    }
+  }
+});
 var comments2 = defineCommand({
   args: {
     "api-key": {
@@ -4599,6 +5379,152 @@ var dashboard = defineCommand({
     }
   }
 });
+var dataLsCommand = defineCommand({
+  args: {
+    collection: {
+      description: "Collection name",
+      required: true,
+      type: "positional"
+    },
+    dir: {
+      default: ".",
+      description: "Published directory",
+      type: "positional"
+    },
+    json: { description: "Machine-readable output", type: "boolean" },
+    limit: { description: "Max records to show", type: "string" }
+  },
+  meta: {
+    description: "List records in a collection",
+    name: "ls"
+  },
+  async run({ args }) {
+    try {
+      await dataLs({
+        collection: args.collection,
+        dir: args.dir,
+        json: Boolean(args.json),
+        limit: args.limit === void 0 ? void 0 : Number(args.limit)
+      });
+    } catch (err) {
+      printCliError(err, Boolean(args.json));
+      process.exit(1);
+    }
+  }
+});
+var dataInsertCommand = defineCommand({
+  args: {
+    collection: {
+      description: "Collection name",
+      required: true,
+      type: "positional"
+    },
+    dir: {
+      default: ".",
+      description: "Published directory",
+      type: "positional"
+    },
+    file: {
+      description: "Read the record(s) from a JSON file instead of --record",
+      type: "string"
+    },
+    json: { description: "Machine-readable output", type: "boolean" },
+    record: {
+      description: "A JSON object, or an array of objects for a batch",
+      type: "string"
+    }
+  },
+  meta: {
+    description: "Insert one or many records into a collection",
+    name: "insert"
+  },
+  async run({ args }) {
+    try {
+      await dataInsert({
+        collection: args.collection,
+        dir: args.dir,
+        file: args.file,
+        json: Boolean(args.json),
+        record: args.record
+      });
+    } catch (err) {
+      printCliError(err, Boolean(args.json));
+      process.exit(1);
+    }
+  }
+});
+var dataExportCommand = defineCommand({
+  args: {
+    dir: {
+      default: ".",
+      description: "Published directory",
+      type: "positional"
+    },
+    // Output is always JSON; accepted so --json works uniformly across
+    // every command (SPEC-2 milestone 20 → CLI integration).
+    json: {
+      description: "Machine-readable output (always on)",
+      type: "boolean"
+    }
+  },
+  meta: {
+    description: "Export every collection's records as JSON",
+    name: "export"
+  },
+  async run({ args }) {
+    try {
+      await dataExport({ dir: args.dir });
+    } catch (err) {
+      printCliError(err, true);
+      process.exit(1);
+    }
+  }
+});
+var dataClearCommand = defineCommand({
+  args: {
+    collection: {
+      description: "Collection name",
+      required: true,
+      type: "positional"
+    },
+    dir: {
+      default: ".",
+      description: "Published directory",
+      type: "positional"
+    },
+    json: { description: "Machine-readable output", type: "boolean" },
+    yes: { description: "Confirm deleting every record", type: "boolean" }
+  },
+  meta: {
+    description: "Delete every record in a collection",
+    name: "clear"
+  },
+  async run({ args }) {
+    try {
+      await dataClear({
+        collection: args.collection,
+        dir: args.dir,
+        json: Boolean(args.json),
+        yes: Boolean(args.yes)
+      });
+    } catch (err) {
+      printCliError(err, Boolean(args.json));
+      process.exit(1);
+    }
+  }
+});
+var data = defineCommand({
+  meta: {
+    description: "Read, insert, or clear the artifact's shared records",
+    name: "data"
+  },
+  subCommands: {
+    clear: dataClearCommand,
+    export: dataExportCommand,
+    insert: dataInsertCommand,
+    ls: dataLsCommand
+  }
+});
 var main = defineCommand({
   meta: {
     description: "Publish AI-generated artifacts for review \u2014 https://artifact.cafe",
@@ -4621,8 +5547,10 @@ var main = defineCommand({
     comment: comment2,
     comments: comments2,
     dashboard,
+    data,
     delete: del,
     edit,
+    expiration: expiration2,
     folders: folders2,
     link: link2,
     list: list2,