@antasphere/slideless 0.13.14 → 0.14.1

package/dist/bin.js

@@ -4146,12 +4146,12 @@ var CliAuthClient = class {
     });
     if (res.status === 204)
       return void 0;
-    const json2 = await res.json().catch(() => null);
+    const json3 = await res.json().catch(() => null);
     if (!res.ok) {
-      const errBody = json2 ?? {};
+      const errBody = json3 ?? {};
       throw new CliAuthError(res.status, errBody.error?.code ?? "unknown_error", errBody.error?.message ?? `Request failed with ${res.status}`, errBody.error?.details);
     }
-    return json2;
+    return json3;
   }
 };
 
@@ -4233,12 +4233,12 @@ var CliConnectClient = class {
     if (apiKey)
       headers["authorization"] = `Bearer ${apiKey}`;
     const res = await this.fetchImpl(url2, { method: "POST", headers, body: JSON.stringify(body) });
-    const json2 = await res.json().catch(() => null);
+    const json3 = await res.json().catch(() => null);
     if (!res.ok) {
-      const errBody = json2 ?? {};
+      const errBody = json3 ?? {};
       throw new CliConnectError(stage, res.status, errBody.error?.code ?? "unknown_error", errBody.error?.message ?? `Request failed with ${res.status}`, errBody.error?.details);
     }
-    return json2;
+    return json3;
   }
 };
 
@@ -4477,12 +4477,12 @@ var ChassisClient = class {
   async parse(res) {
     if (res.status === 204)
       return void 0;
-    const json2 = await res.json().catch(() => null);
+    const json3 = await res.json().catch(() => null);
     if (!res.ok) {
-      const errBody = json2 ?? {};
+      const errBody = json3 ?? {};
       throw new PlatformApiError(res.status, errBody.error?.code ?? "unknown_error", errBody.error?.message ?? `Request failed with ${res.status}`, errBody.error?.details);
     }
-    return json2;
+    return json3;
   }
   /** Append cursor-pagination params to a list path. */
   pathWithQuery(base, params, extra = {}) {
@@ -12218,7 +12218,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve9) {
+function isRecursive(inst, stack, resolve10) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -12228,7 +12228,7 @@ function isRecursive(inst, stack, resolve9) {
   let result = NONE;
   const check3 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve9);
+      const answer = isRecursive(child, stack, resolve10);
       if (answer > result)
         result = answer;
     }
@@ -12239,7 +12239,7 @@ function isRecursive(inst, stack, resolve9) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve9) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve10) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -12303,7 +12303,7 @@ function isRecursive(inst, stack, resolve9) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve9 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve10 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -22798,13 +22798,13 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function handleUnrepresentable(schema, ctx, json2, params, message) {
+function handleUnrepresentable(schema, ctx, json3, params, message) {
   const result = typeof ctx.unrepresentable === "function" ? ctx.unrepresentable({ zodSchema: schema, path: params.path, message }) : ctx.unrepresentable;
   if (result === "any")
     return false;
   if (result === void 0 || result === "throw")
     throw new Error(message);
-  Object.assign(json2, result);
+  Object.assign(json3, result);
   return true;
 }
 function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
@@ -23040,12 +23040,12 @@ function foldObjects(members2) {
   }
   return folded;
 }
-function foldIntersection(json2) {
-  const allOf = json2.allOf;
+function foldIntersection(json3) {
+  const allOf = json3.allOf;
   if (!Array.isArray(allOf) || allOf.length < 2)
     return;
   for (const key of FOLDABLE_KEYS)
-    if (key in json2)
+    if (key in json3)
       return;
   const unions = allOf.filter((m) => UNION_KEYS.some((k) => Array.isArray(m[k])));
   let folded = null;
@@ -23064,8 +23064,8 @@ function foldIntersection(json2) {
   }
   if (!folded)
     return;
-  delete json2.allOf;
-  assignProps(json2, folded);
+  delete json3.allOf;
+  assignProps(json3, folded);
 }
 function finalize(ctx, schema) {
   const root = ctx.seen.get(schema);
@@ -23147,20 +23147,20 @@ function finalize(ctx, schema) {
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
       for (const seen of ctx.seen.values()) {
-        for (const json2 of [seen.schema, seen.def]) {
-          const allOf = json2?.allOf;
+        for (const json3 of [seen.schema, seen.def]) {
+          const allOf = json3?.allOf;
           if (!Array.isArray(allOf))
             continue;
           const existing = carriers.get(allOf);
           if (existing)
-            existing.push(json2);
+            existing.push(json3);
           else
-            carriers.set(allOf, [json2]);
+            carriers.set(allOf, [json3]);
         }
       }
       for (const allOf of ctx.intersections) {
-        for (const json2 of carriers.get(allOf) ?? [])
-          foldIntersection(json2);
+        for (const json3 of carriers.get(allOf) ?? [])
+          foldIntersection(json3);
       }
     }
   }
@@ -23395,29 +23395,29 @@ var exactPatterns = /* @__PURE__ */ new Map([
 ]);
 var exactPattern = (p) => exactPatterns.get(p) ?? p;
 var stringProcessor = (schema, ctx, _json, _params) => {
-  const json2 = _json;
-  json2.type = "string";
+  const json3 = _json;
+  json3.type = "string";
   const { minimum, maximum, format: format2, patterns, contentEncoding, laxFormat } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minLength = minimum;
+    json3.minLength = minimum;
   if (typeof maximum === "number")
-    json2.maxLength = maximum;
+    json3.maxLength = maximum;
   if (format2) {
-    json2.format = formatMap[format2] ?? format2;
-    if (json2.format === "")
-      delete json2.format;
+    json3.format = formatMap[format2] ?? format2;
+    if (json3.format === "")
+      delete json3.format;
     if (format2 === "time" || laxFormat) {
-      delete json2.format;
+      delete json3.format;
     }
   }
   if (contentEncoding)
-    json2.contentEncoding = contentEncoding;
+    json3.contentEncoding = contentEncoding;
   if (patterns && patterns.size > 0) {
     const patternList = [...patterns].map(exactPattern);
     if (patternList.length === 1)
-      json2.pattern = patternList[0].source;
+      json3.pattern = patternList[0].source;
     else if (patternList.length > 1) {
-      json2.allOf = [
+      json3.allOf = [
         ...patternList.map((regex2) => ({
           ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
           pattern: regex2.source
@@ -23427,31 +23427,31 @@ var stringProcessor = (schema, ctx, _json, _params) => {
   }
 };
 var numberProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const { minimum, maximum, multipleOf, exclusiveMaximum, exclusiveMinimum, isInt } = aggregateChecks(schema);
-  json2.type = isInt ? "integer" : "number";
+  json3.type = isInt ? "integer" : "number";
   const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
   const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
   const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
   if (exMin) {
     if (legacy) {
-      json2.minimum = exclusiveMinimum;
-      json2.exclusiveMinimum = true;
+      json3.minimum = exclusiveMinimum;
+      json3.exclusiveMinimum = true;
     } else {
-      json2.exclusiveMinimum = exclusiveMinimum;
+      json3.exclusiveMinimum = exclusiveMinimum;
     }
   } else if (typeof minimum === "number") {
-    json2.minimum = minimum;
+    json3.minimum = minimum;
   }
   if (exMax) {
     if (legacy) {
-      json2.maximum = exclusiveMaximum;
-      json2.exclusiveMaximum = true;
+      json3.maximum = exclusiveMaximum;
+      json3.exclusiveMaximum = true;
     } else {
-      json2.exclusiveMaximum = exclusiveMaximum;
+      json3.exclusiveMaximum = exclusiveMaximum;
     }
   } else if (typeof maximum === "number") {
-    json2.maximum = maximum;
+    json3.maximum = maximum;
   }
   if (multipleOf) {
     const divisors = /* @__PURE__ */ new Set();
@@ -23459,75 +23459,75 @@ var numberProcessor = (schema, ctx, _json, params) => {
       if (Number.isFinite(divisor) && divisor !== 0)
         divisors.add(Math.abs(divisor));
       else
-        handleUnrepresentable(schema, ctx, json2, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
+        handleUnrepresentable(schema, ctx, json3, params, `A multipleOf divisor of ${divisor} cannot be represented in JSON Schema`);
     }
     const [first, ...rest] = divisors;
     if (first !== void 0)
-      json2.multipleOf = first;
+      json3.multipleOf = first;
     if (rest.length)
-      json2.allOf = [...json2.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
+      json3.allOf = [...json3.allOf ?? [], ...rest.map((m) => ({ multipleOf: m }))];
   }
 };
-var booleanProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var booleanProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
-var bigintProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt cannot be represented in JSON Schema");
+var bigintProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt cannot be represented in JSON Schema");
 };
-var symbolProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Symbols cannot be represented in JSON Schema");
+var symbolProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Symbols cannot be represented in JSON Schema");
 };
-var nullProcessor = (_schema, ctx, json2, _params) => {
+var nullProcessor = (_schema, ctx, json3, _params) => {
   if (ctx.target === "openapi-3.0") {
-    json2.type = "string";
-    json2.nullable = true;
-    json2.enum = [null];
+    json3.type = "string";
+    json3.nullable = true;
+    json3.enum = [null];
   } else {
-    json2.type = "null";
+    json3.type = "null";
   }
 };
-var undefinedProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Undefined cannot be represented in JSON Schema");
+var undefinedProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Undefined cannot be represented in JSON Schema");
 };
-var voidProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Void cannot be represented in JSON Schema");
+var voidProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Void cannot be represented in JSON Schema");
 };
-var neverProcessor = (_schema, _ctx, json2, _params) => {
-  json2.not = {};
+var neverProcessor = (_schema, _ctx, json3, _params) => {
+  json3.not = {};
 };
 var anyProcessor = (_schema, _ctx, _json, _params) => {
 };
 var unknownProcessor = (_schema, _ctx, _json, _params) => {
 };
-var dateProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Date cannot be represented in JSON Schema");
+var dateProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Date cannot be represented in JSON Schema");
 };
-var enumProcessor = (schema, _ctx, json2, _params) => {
+var enumProcessor = (schema, _ctx, json3, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
   if (values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   if (values.every((v) => typeof v === "number"))
-    json2.type = "number";
+    json3.type = "number";
   if (values.every((v) => typeof v === "string"))
-    json2.type = "string";
-  json2.enum = values;
+    json3.type = "string";
+  json3.enum = values;
 };
-var literalProcessor = (schema, ctx, json2, params) => {
+var literalProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   if (def.values.length === 0) {
-    json2.not = {};
+    json3.not = {};
     return;
   }
   const vals = [];
   for (const val of def.values) {
     if (val === void 0) {
-      if (handleUnrepresentable(schema, ctx, json2, params, "Literal `undefined` cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "Literal `undefined` cannot be represented in JSON Schema"))
         return;
     } else if (typeof val === "bigint") {
-      if (handleUnrepresentable(schema, ctx, json2, params, "BigInt literals cannot be represented in JSON Schema"))
+      if (handleUnrepresentable(schema, ctx, json3, params, "BigInt literals cannot be represented in JSON Schema"))
         return;
       vals.push(Number(val));
     } else {
@@ -23537,37 +23537,37 @@ var literalProcessor = (schema, ctx, json2, params) => {
   if (vals.length === 0) {
   } else if (vals.length === 1) {
     const val = vals[0];
-    json2.type = val === null ? "null" : typeof val;
+    json3.type = val === null ? "null" : typeof val;
     if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
-      json2.enum = [val];
+      json3.enum = [val];
     } else {
-      json2.const = val;
+      json3.const = val;
     }
   } else {
     if (vals.every((v) => typeof v === "number"))
-      json2.type = "number";
+      json3.type = "number";
     if (vals.every((v) => typeof v === "string"))
-      json2.type = "string";
+      json3.type = "string";
     if (vals.every((v) => typeof v === "boolean"))
-      json2.type = "boolean";
+      json3.type = "boolean";
     if (vals.every((v) => v === null))
-      json2.type = "null";
-    json2.enum = vals;
+      json3.type = "null";
+    json3.enum = vals;
   }
 };
-var nanProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "NaN cannot be represented in JSON Schema");
+var nanProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "NaN cannot be represented in JSON Schema");
 };
-var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var templateLiteralProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   const pattern = schema._zod.pattern;
   if (!pattern)
     throw new Error("Pattern not found in template literal");
   _json.type = "string";
   _json.pattern = pattern.source;
 };
-var fileProcessor = (schema, _ctx, json2, _params) => {
-  const _json = json2;
+var fileProcessor = (schema, _ctx, json3, _params) => {
+  const _json = json3;
   _json.type = "string";
   _json.format = "binary";
   _json.contentEncoding = "binary";
@@ -23585,34 +23585,34 @@ var fileProcessor = (schema, _ctx, json2, _params) => {
   else
     _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
 };
-var successProcessor = (_schema, _ctx, json2, _params) => {
-  json2.type = "boolean";
+var successProcessor = (_schema, _ctx, json3, _params) => {
+  json3.type = "boolean";
 };
-var customProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Custom types cannot be represented in JSON Schema");
+var customProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Custom types cannot be represented in JSON Schema");
 };
-var functionProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Function types cannot be represented in JSON Schema");
+var functionProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Function types cannot be represented in JSON Schema");
 };
-var transformProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Transforms cannot be represented in JSON Schema");
+var transformProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Transforms cannot be represented in JSON Schema");
 };
-var mapProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Map cannot be represented in JSON Schema");
+var mapProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Map cannot be represented in JSON Schema");
 };
-var setProcessor = (schema, ctx, json2, params) => {
-  handleUnrepresentable(schema, ctx, json2, params, "Set cannot be represented in JSON Schema");
+var setProcessor = (schema, ctx, json3, params) => {
+  handleUnrepresentable(schema, ctx, json3, params, "Set cannot be represented in JSON Schema");
 };
 var arrayProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
-  json2.type = "array";
-  json2.items = processSchema(def.element, ctx, {
+    json3.maxItems = maximum;
+  json3.type = "array";
+  json3.items = processSchema(def.element, ctx, {
     ...params,
     path: [...params.path, "items"]
   });
@@ -23628,17 +23628,17 @@ function inputOptin(schema) {
   return schema._zod.optin;
 }
 var objectProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
   const shape = def.shape;
   const symbolKeys = Object.getOwnPropertySymbols(shape);
-  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json2, params, "Symbol keys cannot be represented in JSON Schema")) {
+  if (symbolKeys.length && handleUnrepresentable(schema, ctx, json3, params, "Symbol keys cannot be represented in JSON Schema")) {
     return;
   }
-  json2.type = "object";
-  json2.properties = {};
+  json3.type = "object";
+  json3.properties = {};
   for (const key in shape) {
-    assignProp(json2.properties, key, processSchema(shape[key], ctx, {
+    assignProp(json3.properties, key, processSchema(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     }));
@@ -23651,21 +23651,21 @@ var objectProcessor = (schema, ctx, _json, params) => {
     }
   }
   if (requiredKeys.length > 0) {
-    json2.required = requiredKeys;
+    json3.required = requiredKeys;
   }
   if (def.catchall?._zod.def.type === "never") {
-    json2.additionalProperties = false;
+    json3.additionalProperties = false;
   } else if (!def.catchall) {
     if (ctx.io === "output")
-      json2.additionalProperties = false;
+      json3.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = processSchema(def.catchall, ctx, {
+    json3.additionalProperties = processSchema(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
   }
 };
-var unionProcessor = (schema, ctx, json2, params) => {
+var unionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
   const options = def.options.map((x, i) => processSchema(x, ctx, {
@@ -23673,12 +23673,12 @@ var unionProcessor = (schema, ctx, json2, params) => {
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
   if (isExclusive) {
-    json2.oneOf = options;
+    json3.oneOf = options;
   } else {
-    json2.anyOf = options;
+    json3.anyOf = options;
   }
 };
-var intersectionProcessor = (schema, ctx, json2, params) => {
+var intersectionProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const a = processSchema(def.left, ctx, {
     ...params,
@@ -23693,13 +23693,13 @@ var intersectionProcessor = (schema, ctx, json2, params) => {
     ...isSimpleIntersection(a) ? a.allOf : [a],
     ...isSimpleIntersection(b) ? b.allOf : [b]
   ];
-  json2.allOf = allOf;
+  json3.allOf = allOf;
   ctx.intersections.push(allOf);
 };
 var tupleProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "array";
+  json3.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
   const prefixItems = def.items.map((x, i) => processSchema(x, ctx, {
@@ -23721,70 +23721,70 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   const maxItems = def.items.length;
   const isClosed = !def.rest;
   if (ctx.target === "draft-2020-12") {
-    json2.prefixItems = prefixItems;
+    json3.prefixItems = prefixItems;
     if (isClosed) {
-      json2.items = false;
+      json3.items = false;
     } else if (rest) {
-      json2.items = rest;
+      json3.items = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else if (ctx.target === "openapi-3.0") {
-    json2.items = {
+    json3.items = {
       anyOf: prefixItems
     };
     if (rest) {
-      json2.items.anyOf.push(rest);
+      json3.items.anyOf.push(rest);
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   } else {
-    json2.items = prefixItems;
+    json3.items = prefixItems;
     if (isClosed) {
-      json2.additionalItems = false;
+      json3.additionalItems = false;
     } else if (rest) {
-      json2.additionalItems = rest;
+      json3.additionalItems = rest;
     }
     if (minItems > 0)
-      json2.minItems = minItems;
+      json3.minItems = minItems;
     if (isClosed)
-      json2.maxItems = maxItems;
+      json3.maxItems = maxItems;
   }
   const { minimum, maximum } = aggregateChecks(schema);
   if (typeof minimum === "number")
-    json2.minItems = minimum;
+    json3.minItems = minimum;
   if (typeof maximum === "number")
-    json2.maxItems = maximum;
+    json3.maxItems = maximum;
 };
-function stringifyKeyNames(bySchema, json2, visited) {
-  if (json2.$ref) {
-    if (visited.has(json2))
-      return json2;
-    visited.add(json2);
-    const def = bySchema.get(json2)?.def;
+function stringifyKeyNames(bySchema, json3, visited) {
+  if (json3.$ref) {
+    if (visited.has(json3))
+      return json3;
+    visited.add(json3);
+    const def = bySchema.get(json3)?.def;
     if (!def)
-      return json2;
+      return json3;
     const inlined = stringifyKeyNames(bySchema, def, visited);
-    return inlined === def ? json2 : inlined;
+    return inlined === def ? json3 : inlined;
   }
   for (const keyword of ["anyOf", "oneOf"]) {
-    const branches = json2[keyword];
+    const branches = json3[keyword];
     if (!Array.isArray(branches))
       continue;
     const mapped = branches.map((branch) => stringifyKeyNames(bySchema, branch, visited));
     if (mapped.some((branch, i) => branch !== branches[i]))
-      json2 = { ...json2, [keyword]: mapped };
+      json3 = { ...json3, [keyword]: mapped };
   }
-  const types = Array.isArray(json2.type) ? json2.type : [json2.type];
+  const types = Array.isArray(json3.type) ? json3.type : [json3.type];
   const numericType = !types.includes("string") && types.some((t) => t === "number" || t === "integer");
-  const values = json2.enum ?? (json2.const !== void 0 ? [json2.const] : void 0);
+  const values = json3.enum ?? (json3.const !== void 0 ? [json3.const] : void 0);
   if (!numericType && !values?.some((v) => typeof v === "number"))
-    return json2;
-  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format: format2, id: id2, ...rest } = json2;
+    return json3;
+  const { minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf, format: format2, id: id2, ...rest } = json3;
   if (rest.enum)
     rest.enum = rest.enum.map((v) => typeof v === "number" ? String(v) : v);
   else if (typeof rest.const === "number")
@@ -23824,9 +23824,9 @@ function rewriteKeyNames(ctx) {
   }
 }
 var recordProcessor = (schema, ctx, _json, params) => {
-  const json2 = _json;
+  const json3 = _json;
   const def = schema._zod.def;
-  json2.type = "object";
+  json3.type = "object";
   const keyType = def.keyType;
   const patterns = aggregateChecks(keyType).patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
@@ -23834,13 +23834,13 @@ var recordProcessor = (schema, ctx, _json, params) => {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
-    json2.patternProperties = {};
+    json3.patternProperties = {};
     for (const pattern of patterns) {
-      assignProp(json2.patternProperties, exactPattern(pattern).source, valueSchema);
+      assignProp(json3.patternProperties, exactPattern(pattern).source, valueSchema);
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = processSchema(def.keyType, ctx, {
+      json3.propertyNames = processSchema(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
@@ -23852,7 +23852,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
       }
       pending.push(schema);
     }
-    json2.additionalProperties = processSchema(def.valueType, ctx, {
+    json3.additionalProperties = processSchema(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -23862,19 +23862,19 @@ var recordProcessor = (schema, ctx, _json, params) => {
   if (keyValues && !def.partial && !omittableOnInput) {
     const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
     if (validKeyValues.length > 0) {
-      json2.required = validKeyValues.map(String);
+      json3.required = validKeyValues.map(String);
     }
   }
 };
-var nullableProcessor = (schema, ctx, json2, params) => {
+var nullableProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   const inner = processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
-    json2.nullable = true;
+    json3.nullable = true;
   } else {
-    json2.anyOf = [inner, { type: "null" }];
+    json3.anyOf = [inner, { type: "null" }];
   }
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
@@ -23884,7 +23884,7 @@ var nonoptionalProcessor = (schema, ctx, _json, params) => {
   seen.ref = def.innerType;
 };
 var UNREPRESENTABLE_DEFAULT = Symbol();
-function serializeDefaultValue(value, schema, ctx, json2, params) {
+function serializeDefaultValue(value, schema, ctx, json3, params) {
   let unrepresentable = false;
   const serialized = JSON.stringify(value, (_, val) => {
     if (typeof val !== "bigint")
@@ -23894,30 +23894,30 @@ function serializeDefaultValue(value, schema, ctx, json2, params) {
   });
   if (!unrepresentable)
     return JSON.parse(serialized);
-  handleUnrepresentable(schema, ctx, json2, params, "BigInt defaults cannot be represented in JSON Schema");
+  handleUnrepresentable(schema, ctx, json3, params, "BigInt defaults cannot be represented in JSON Schema");
   return UNREPRESENTABLE_DEFAULT;
 }
-var defaultProcessor = (schema, ctx, json2, params) => {
+var defaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2.default = value;
+    json3.default = value;
 };
-var prefaultProcessor = (schema, ctx, json2, params) => {
+var prefaultProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io !== "input")
     return;
-  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
+  const value = serializeDefaultValue(def.defaultValue, schema, ctx, json3, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
-    json2._prefault = value;
+    json3._prefault = value;
 };
-var catchProcessor = (schema, ctx, json2, params) => {
+var catchProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
@@ -23926,10 +23926,10 @@ var catchProcessor = (schema, ctx, json2, params) => {
   try {
     catchValue = def.catchValue(void 0);
   } catch {
-    handleUnrepresentable(schema, ctx, json2, params, "Dynamic catch values are not supported in JSON Schema");
+    handleUnrepresentable(schema, ctx, json3, params, "Dynamic catch values are not supported in JSON Schema");
     return;
   }
-  json2.default = catchValue;
+  json3.default = catchValue;
 };
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -23939,12 +23939,12 @@ var pipeProcessor = (schema, ctx, _json, params) => {
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
-var readonlyProcessor = (schema, ctx, json2, params) => {
+var readonlyProcessor = (schema, ctx, json3, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
-  json2.readOnly = true;
+  json3.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
@@ -24586,7 +24586,7 @@ var _ZodString = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodString.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => stringProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     format: (inst) => aggregateChecks(inst).format ?? null,
@@ -24945,7 +24945,7 @@ var ZodNumber = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodNumber.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => numberProcessor(inst, ctx, json3, params);
     inst.isFinite = true;
   },
   /* @__PURE__ */ util_exports.derived({
@@ -25035,7 +25035,7 @@ function uint32(params) {
 var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => booleanProcessor(inst, ctx, json3, params);
 });
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
@@ -25045,7 +25045,7 @@ var ZodBigInt = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => bigintProcessor(inst, ctx, json3, params);
   },
   /* @__PURE__ */ util_exports.derived({
     minValue: (inst) => aggregateChecks(inst).minimum ?? null,
@@ -25103,7 +25103,7 @@ function uint64(params) {
 var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
   $ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => symbolProcessor(inst, ctx, json3, params);
 });
 function symbol(params) {
   return _symbol(ZodSymbol, params);
@@ -25111,7 +25111,7 @@ function symbol(params) {
 var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
   $ZodUndefined.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => undefinedProcessor(inst, ctx, json3, params);
 });
 function _undefined3(params) {
   return _undefined2(ZodUndefined, params);
@@ -25119,7 +25119,7 @@ function _undefined3(params) {
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullProcessor(inst, ctx, json3, params);
 });
 function _null3(params) {
   return _null2(ZodNull, params);
@@ -25127,7 +25127,7 @@ function _null3(params) {
 var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
   $ZodAny.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => anyProcessor(inst, ctx, json3, params);
 });
 function any() {
   return _any(ZodAny);
@@ -25135,7 +25135,7 @@ function any() {
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unknownProcessor(inst, ctx, json3, params);
 });
 function unknown() {
   return _unknown(ZodUnknown);
@@ -25143,7 +25143,7 @@ function unknown() {
 var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
   $ZodNever.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => neverProcessor(inst, ctx, json3, params);
 });
 function never(params) {
   return _never(ZodNever, params);
@@ -25151,7 +25151,7 @@ function never(params) {
 var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
   $ZodVoid.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => voidProcessor(inst, ctx, json3, params);
 });
 function _void2(params) {
   return _void(ZodVoid, params);
@@ -25161,7 +25161,7 @@ var ZodDate = /* @__PURE__ */ $constructor(
   (inst, def) => {
     $ZodDate.init(inst, def);
     ZodType.init(inst, def);
-    inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
+    inst._zod.processJSONSchema = (ctx, json3, params) => dateProcessor(inst, ctx, json3, params);
     inst.min = (value, params) => inst.check(_gte(value, params));
     inst.max = (value, params) => inst.check(_lte(value, params));
   },
@@ -25183,7 +25183,7 @@ var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => arrayProcessor(inst, ctx, json3, params);
   inst.element = def.element;
 }, {
   min(n, params) {
@@ -25213,7 +25213,7 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodObjectJIT.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => objectProcessor(inst, ctx, json3, params);
   util_exports.installLazyProp(inst, "shape", (self2) => self2._zod.def.shape, false);
 }, {
   keyof() {
@@ -25286,7 +25286,7 @@ function looseObject(shape, params) {
 var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
   $ZodUnion.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function union(options, params) {
@@ -25299,7 +25299,7 @@ function union(options, params) {
 var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
   ZodUnion.init(inst, def);
   $ZodXor.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => unionProcessor(inst, ctx, json3, params);
   inst.options = def.options;
 });
 function xor(options, params) {
@@ -25325,7 +25325,7 @@ function discriminatedUnion(discriminator, options, params) {
 var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
   $ZodIntersection.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => intersectionProcessor(inst, ctx, json3, params);
 });
 function intersection(left, right) {
   return new ZodIntersection({
@@ -25338,7 +25338,7 @@ var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTuple.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => tupleProcessor(inst, ctx, json3, params);
 }, {
   rest(rest) {
     return this.clone({
@@ -25371,7 +25371,7 @@ var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodRecord.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => recordProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
 });
@@ -25413,7 +25413,7 @@ var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodMap.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => mapProcessor(inst, ctx, json3, params);
   inst.keyType = def.keyType;
   inst.valueType = def.valueType;
   inst.min = (...args) => inst.check(_minSize(...args));
@@ -25433,7 +25433,7 @@ var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodSet.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => setProcessor(inst, ctx, json3, params);
   inst.min = (...args) => inst.check(_minSize(...args));
   inst.nonempty = (params) => inst.check(_minSize(1, params));
   inst.max = (...args) => inst.check(_maxSize(...args));
@@ -25449,7 +25449,7 @@ function set(valueType, params) {
 var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   $ZodEnum.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => enumProcessor(inst, ctx, json3, params);
   inst.enum = def.entries;
   inst.options = [...inst._zod.values];
   const keys = new Set(Object.keys(def.entries));
@@ -25502,7 +25502,7 @@ function nativeEnum(entries, params) {
 var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
   $ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => literalProcessor(inst, ctx, json3, params);
   inst.values = new Set(def.values);
   Object.defineProperty(inst, "value", {
     get() {
@@ -25523,7 +25523,7 @@ function literal(value, params) {
 var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   $ZodFile.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => fileProcessor(inst, ctx, json3, params);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
   inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
@@ -25535,7 +25535,7 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
   _ensureDefaultMemoizer();
   $ZodTransform.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => transformProcessor(inst, ctx, json3, params);
   inst._zod.parse = (payload, _ctx) => {
     if (_ctx.direction === "backward") {
       throw new $ZodEncodeError(inst.constructor.name);
@@ -25574,7 +25574,7 @@ function transform(fn) {
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
   $ZodOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function optional(innerType) {
@@ -25586,7 +25586,7 @@ function optional(innerType) {
 var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
   $ZodExactOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => optionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function exactOptional(innerType) {
@@ -25598,7 +25598,7 @@ function exactOptional(innerType) {
 var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
   $ZodNullable.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nullableProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nullable(innerType) {
@@ -25613,7 +25613,7 @@ function nullish2(innerType) {
 var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
   $ZodDefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => defaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeDefault = inst.unwrap;
 });
@@ -25629,7 +25629,7 @@ function _default2(innerType, defaultValue) {
 var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
   $ZodPrefault.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => prefaultProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function prefault(innerType, defaultValue) {
@@ -25644,7 +25644,7 @@ function prefault(innerType, defaultValue) {
 var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
   $ZodNonOptional.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nonoptionalProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function nonoptional(innerType, params) {
@@ -25657,7 +25657,7 @@ function nonoptional(innerType, params) {
 var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
   $ZodSuccess.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => successProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function success(innerType) {
@@ -25669,7 +25669,7 @@ function success(innerType) {
 var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
   $ZodCatch.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => catchProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
   inst.removeCatch = inst.unwrap;
 });
@@ -25683,7 +25683,7 @@ function _catch2(innerType, catchValue) {
 var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
   $ZodNaN.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => nanProcessor(inst, ctx, json3, params);
 });
 function nan(params) {
   return _nan(ZodNaN, params);
@@ -25691,7 +25691,7 @@ function nan(params) {
 var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
   $ZodPipe.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => pipeProcessor(inst, ctx, json3, params);
   inst.in = def.in;
   inst.out = def.out;
 });
@@ -25733,7 +25733,7 @@ var ZodPreprocess = /* @__PURE__ */ $constructor("ZodPreprocess", (inst, def) =>
 var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
   $ZodReadonly.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => readonlyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function readonly(innerType) {
@@ -25745,7 +25745,7 @@ function readonly(innerType) {
 var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
   $ZodTemplateLiteral.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => templateLiteralProcessor(inst, ctx, json3, params);
 });
 function templateLiteral(parts, params) {
   return new ZodTemplateLiteral({
@@ -25757,7 +25757,7 @@ function templateLiteral(parts, params) {
 var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
   $ZodLazy.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => lazyProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.getter();
 });
 function lazy(getter) {
@@ -25769,7 +25769,7 @@ function lazy(getter) {
 var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
   $ZodPromise.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => promiseProcessor(inst, ctx, json3, params);
   inst.unwrap = () => inst._zod.def.innerType;
 });
 function promise(innerType) {
@@ -25781,7 +25781,7 @@ function promise(innerType) {
 var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
   $ZodFunction.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => functionProcessor(inst, ctx, json3, params);
 });
 function _function(params) {
   return new ZodFunction({
@@ -25793,7 +25793,7 @@ function _function(params) {
 var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   $ZodCustom.init(inst, def);
   ZodType.init(inst, def);
-  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
+  inst._zod.processJSONSchema = (ctx, json3, params) => customProcessor(inst, ctx, json3, params);
 });
 function check(fn) {
   const ch = new $ZodCheck({
@@ -33390,19 +33390,19 @@ async function readLink(rootDir) {
     return null;
   }
 }
-async function writeLink(rootDir, link) {
-  await writeFile2(join3(rootDir, LINK_FILENAME), `${JSON.stringify(link, null, 2)}
+async function writeLink(rootDir, link2) {
+  await writeFile2(join3(rootDir, LINK_FILENAME), `${JSON.stringify(link2, null, 2)}
 `);
 }
 async function linkedDeckId(ctx, rootDir, howElse) {
-  const link = await readLink(rootDir);
-  if (!link) return null;
-  if (link.baseUrl !== ctx.baseUrl) {
+  const link2 = await readLink(rootDir);
+  if (!link2) return null;
+  if (link2.baseUrl !== ctx.baseUrl) {
     throw new CliUsageError(
-      `${LINK_FILENAME} links ${rootDir} to ${link.baseUrl}, but you are working against ${ctx.baseUrl}. ${howElse}`
+      `${LINK_FILENAME} links ${rootDir} to ${link2.baseUrl}, but you are working against ${ctx.baseUrl}. ${howElse}`
     );
   }
-  return link.presentationId;
+  return link2.presentationId;
 }
 
 // src/references.ts
@@ -33868,8 +33868,8 @@ async function pathExists(path) {
 }
 
 // src/commands/content.ts
-import { readFile as readFile6, mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname4, join as join5, resolve as resolve6 } from "node:path";
+import { readFile as readFile7, mkdir as mkdir5, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5, join as join6, resolve as resolve7 } from "node:path";
 
 // src/download.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -33903,10 +33903,247 @@ function sha256Hex(bytes) {
 }
 
 // src/devserver.ts
-import { watch } from "node:fs";
-import { readFile as readFile5, realpath as realpath2, stat as stat3 } from "node:fs/promises";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { createReadStream as createReadStream3, watch } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile6, realpath as realpath3, stat as stat4 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve5 } from "node:path";
+
+// src/localversions.ts
+import { createHash as createHash3, randomBytes } from "node:crypto";
+import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "node:fs";
+import { link, mkdir as mkdir3, readdir as readdir2, readFile as readFile5, realpath as realpath2, rename, rm, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve4 } from "node:path";
+import { pipeline as pipeline3 } from "node:stream/promises";
+import { Transform } from "node:stream";
+var LOCAL_STORE_ENV = "SLIDELESS_LOCAL_STORE";
+var SHA256_RE = /^[0-9a-f]{64}$/;
+var RECORD_RE = /^([1-9][0-9]{0,8})\.json$/;
+var MAX_CLAIM_ATTEMPTS = 50;
+function defaultLocalStore(env = process.env) {
+  const fromEnv = env[LOCAL_STORE_ENV]?.trim();
+  if (fromEnv) return resolve4(fromEnv);
+  if (process.platform === "win32") {
+    const base2 = env.LOCALAPPDATA?.trim() || join5(homedir(), "AppData", "Local");
+    return join5(base2, "antasphere", "slideless", "local");
+  }
+  const base = env.XDG_DATA_HOME?.trim() || join5(homedir(), ".local", "share");
+  return join5(base, "antasphere", "slideless", "local");
+}
+async function openLocalStore(target, store, options = {}) {
+  const realRoot = await realpath2(resolve4(target)).catch((err) => {
+    if (err.code === "ENOENT") throw new Error(`No such file or directory: ${target}`);
+    throw err;
+  });
+  const wanted = resolve4(store ?? defaultLocalStore());
+  const realWanted = await realpathOfFuture(wanted);
+  const rootInfo = await stat3(realRoot);
+  const container = rootInfo.isFile() ? dirname4(realRoot) : realRoot;
+  const rel = relative2(container, realWanted);
+  const inside = rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+  const hidden = rel !== "" && rel.split(/[\\/]/).some((segment) => segment.startsWith("."));
+  if (inside && !hidden) {
+    throw new Error(
+      `The version store ${realWanted} is inside the folder it would keep versions of; pass a --store outside it (or under a dot-prefixed directory, which is never scanned)`
+    );
+  }
+  if (options.create === false) {
+    const info = await stat3(realWanted).catch(() => null);
+    return { root: realRoot, store: realWanted, exists: Boolean(info?.isDirectory()) };
+  }
+  await mkdir3(wanted, { recursive: true });
+  return { root: realRoot, store: await realpath2(wanted), exists: true };
+}
+async function realpathOfFuture(path) {
+  const missing = [];
+  let at = path;
+  for (; ; ) {
+    const real = await realpath2(at).catch(() => null);
+    if (real !== null) return missing.length ? join5(real, ...missing.reverse()) : real;
+    const parent = dirname4(at);
+    if (parent === at) return path;
+    missing.push(basename3(at));
+    at = parent;
+  }
+}
+function localVersionsDir(store, realRoot) {
+  return versionsDir(store, realRoot);
+}
+function folderKey(realRoot) {
+  return createHash3("sha256").update(realRoot).digest("hex").slice(0, 24);
+}
+function folderDir(store, realRoot) {
+  return join5(store, "folders", folderKey(realRoot));
+}
+function versionsDir(store, realRoot) {
+  return join5(folderDir(store, realRoot), "versions");
+}
+function blobPath(store, sha256) {
+  if (!SHA256_RE.test(sha256)) throw new Error(`Not a sha256: ${sha256}`);
+  return join5(store, "blobs", sha256.slice(0, 2), sha256);
+}
+async function versionNumbers(store, realRoot) {
+  const names = await readdir2(versionsDir(store, realRoot)).catch(() => []);
+  const out = [];
+  for (const name of names) {
+    const m = RECORD_RE.exec(name);
+    if (m) out.push(Number(m[1]));
+  }
+  return out.sort((a, b) => a - b);
+}
+function parseRecord(raw, expected) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof data !== "object" || data === null) return null;
+  const r = data;
+  if (r.v !== 1 || r.version !== expected || typeof r.entryPath !== "string" || !Array.isArray(r.manifest)) {
+    return null;
+  }
+  for (const f of r.manifest) {
+    if (typeof f !== "object" || f === null || typeof f.path !== "string" || typeof f.sha256 !== "string" || !SHA256_RE.test(f.sha256) || typeof f.sizeBytes !== "number" || typeof f.contentType !== "string") {
+      return null;
+    }
+  }
+  return r;
+}
+async function readLocalVersion(store, realRoot, version2) {
+  if (!Number.isSafeInteger(version2) || version2 < 1) return null;
+  const raw = await readFile5(join5(versionsDir(store, realRoot), `${version2}.json`), "utf8").catch(() => null);
+  return raw === null ? null : parseRecord(raw, version2);
+}
+async function listLocalVersions(store, realRoot) {
+  const out = [];
+  for (const n of await versionNumbers(store, realRoot)) {
+    const record2 = await readLocalVersion(store, realRoot, n);
+    if (!record2) continue;
+    const { manifest: _manifest, v: _v, ...summary } = record2;
+    out.push(summary);
+  }
+  return out;
+}
+async function latestRecord(store, realRoot) {
+  const numbers = await versionNumbers(store, realRoot);
+  for (let i = numbers.length - 1; i >= 0; i--) {
+    const record2 = await readLocalVersion(store, realRoot, numbers[i]);
+    if (record2) return record2;
+  }
+  return null;
+}
+function sameState(a, b) {
+  if (a.entryPath !== b.entryPath || a.manifest.length !== b.manifest.length) return false;
+  return a.manifest.every((f, i) => f.path === b.manifest[i].path && f.sha256 === b.manifest[i].sha256);
+}
+async function storeBlob(store, absPath) {
+  const tmpDir = join5(store, "blobs", "tmp");
+  await mkdir3(tmpDir, { recursive: true });
+  const tmp = join5(tmpDir, `${randomBytes(8).toString("hex")}.part`);
+  const hash2 = createHash3("sha256");
+  let sizeBytes = 0;
+  const tap = new Transform({
+    transform(chunk, _enc, cb) {
+      hash2.update(chunk);
+      sizeBytes += chunk.length;
+      cb(null, chunk);
+    }
+  });
+  try {
+    await pipeline3(createReadStream2(absPath), tap, createWriteStream2(tmp, { flags: "wx" }));
+    const sha256 = hash2.digest("hex");
+    const target = blobPath(store, sha256);
+    const existing = await stat3(target).catch(() => null);
+    if (existing?.isFile() && existing.size === sizeBytes) {
+      await rm(tmp, { force: true });
+    } else {
+      await mkdir3(join5(store, "blobs", sha256.slice(0, 2)), { recursive: true });
+      await rename(tmp, target);
+    }
+    return { sha256, sizeBytes };
+  } catch (err) {
+    await rm(tmp, { force: true });
+    throw err;
+  }
+}
+async function snapshot(target, options = {}) {
+  const { root, store } = await openLocalStore(target, options.store);
+  let scan;
+  try {
+    scan = await scanDeck(root);
+  } catch (err) {
+    const message = err.message;
+    throw new Error(
+      message.startsWith("Nothing to push") ? message.replace("Nothing to push", "Nothing to snapshot") : message
+    );
+  }
+  const entryPath = detectEntry(scan, options.entry);
+  const scanned = { entryPath, manifest: scan.files };
+  const latest = await latestRecord(store, root);
+  if (latest && sameState(latest, scanned)) return unchanged(latest, root, store);
+  const manifest = [];
+  for (const file2 of scan.files) {
+    const kept = await storeBlob(store, file2.absPath);
+    manifest.push({
+      path: file2.path,
+      sha256: kept.sha256,
+      sizeBytes: kept.sizeBytes,
+      contentType: file2.contentType
+    });
+  }
+  const sizeBytes = manifest.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const dir = versionsDir(store, root);
+  await mkdir3(dir, { recursive: true });
+  await writeFile3(join5(folderDir(store, root), "folder.json"), `${JSON.stringify({ v: 1, root })}
+`).catch(
+    () => {
+    }
+  );
+  for (let attempt = 0; attempt < MAX_CLAIM_ATTEMPTS; attempt++) {
+    const current = await latestRecord(store, root);
+    if (current && sameState(current, { entryPath, manifest })) return unchanged(current, root, store);
+    const numbers = await versionNumbers(store, root);
+    const next = (numbers.at(-1) ?? 0) + 1;
+    const record2 = {
+      v: 1,
+      version: next,
+      root,
+      entryPath,
+      createdAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+      fileCount: manifest.length,
+      sizeBytes,
+      manifest
+    };
+    const tmp = join5(dir, `.${randomBytes(8).toString("hex")}.tmp`);
+    await writeFile3(tmp, `${JSON.stringify(record2)}
+`, { flag: "wx" });
+    try {
+      await link(tmp, join5(dir, `${next}.json`));
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw err;
+    } finally {
+      await rm(tmp, { force: true });
+    }
+    return { version: next, created: true, entryPath, fileCount: manifest.length, sizeBytes, root, store };
+  }
+  throw new Error("Could not claim a version number: too many snapshots at once");
+}
+function unchanged(record2, root, store) {
+  return {
+    version: record2.version,
+    created: false,
+    entryPath: record2.entryPath,
+    fileCount: record2.fileCount,
+    sizeBytes: record2.sizeBytes,
+    root,
+    store
+  };
+}
+
+// src/devserver.ts
 var DEV_SANDBOX_CSP = "sandbox allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox allow-modals allow-downloads";
 var CONTENT_HEADERS = {
   "content-security-policy": DEV_SANDBOX_CSP,
@@ -33914,33 +34151,29 @@ var CONTENT_HEADERS = {
   "referrer-policy": "no-referrer",
   "cache-control": "no-store"
 };
+var PLAIN_HEADERS = {
+  "x-content-type-options": "nosniff",
+  "referrer-policy": "no-referrer",
+  "cache-control": "no-store"
+};
+var DEV_ROUTE_PREFIX = "/__slideless/";
 var RELOAD_PATH = "/__slideless/reload";
-var RELOAD_SNIPPET = `<script>
-(() => {
-  const connect = () => {
-    const es = new EventSource('${RELOAD_PATH}');
-    es.addEventListener('reload', () => location.reload());
-    es.onerror = () => { es.close(); setTimeout(connect, 1000); };
-  };
-  connect();
-})();
-</script>`;
-function injectReload(html) {
-  const idx = html.lastIndexOf("</body>");
-  if (idx === -1) return html + RELOAD_SNIPPET;
-  return html.slice(0, idx) + RELOAD_SNIPPET + html.slice(idx);
-}
+var VERSIONS_PATH = "/__slideless/versions";
+var SNAPSHOT_PATH = "/__slideless/snapshot";
+var VERSION_FILE_RE = /^\/__slideless\/v\/([1-9][0-9]{0,8})\/(.*)$/;
+var SNAPSHOT_HEADER = "x-slideless";
+var SNAPSHOT_HEADER_VALUE = "snapshot";
 async function resolveServable(root, relPath) {
-  if (relPath === "" || isAbsolute2(relPath)) return null;
+  if (relPath === "" || isAbsolute3(relPath)) return null;
   if (relPath.includes("\\")) return null;
   if (relPath.split("/").some((seg) => seg.startsWith("."))) return null;
-  const target = resolve4(root, relPath);
-  const lexical = relative2(root, target);
-  if (lexical === "" || lexical.startsWith("..") || isAbsolute2(lexical)) return null;
-  const real = await realpath2(target).catch(() => null);
+  const target = resolve5(root, relPath);
+  const lexical = relative3(root, target);
+  if (lexical === "" || lexical.startsWith("..") || isAbsolute3(lexical)) return null;
+  const real = await realpath3(target).catch(() => null);
   if (real === null) return null;
-  const actual = relative2(root, real);
-  if (actual === "" || actual.startsWith("..") || isAbsolute2(actual)) return null;
+  const actual = relative3(root, real);
+  if (actual === "" || actual.startsWith("..") || isAbsolute3(actual)) return null;
   return real;
 }
 function hostAllowed(req, allowed) {
@@ -33963,11 +34196,288 @@ function allowedHosts(host, port) {
   }
   return out;
 }
+function urlPath(relPath) {
+  return relPath.split("/").map(encodeURIComponent).join("/");
+}
+function json2(res, status, body) {
+  res.writeHead(status, { ...PLAIN_HEADERS, "content-type": "application/json; charset=utf-8" }).end(`${JSON.stringify(body)}
+`);
+}
+function wrapperCsp(nonce) {
+  return [
+    "default-src 'none'",
+    `script-src 'nonce-${nonce}'`,
+    `style-src 'nonce-${nonce}'`,
+    "connect-src 'self'",
+    "frame-src 'self'",
+    "img-src 'self' data:",
+    "base-uri 'none'",
+    "form-action 'none'"
+  ].join("; ");
+}
+function scriptJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function wrapperHtml(nonce, entryPath) {
+  const entryUrl = scriptJson(`/${urlPath(entryPath)}`);
+  const entry = scriptJson(entryPath);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Slideless \xB7 local</title>
+<style nonce="${nonce}">
+  :root { color-scheme: light dark; --ink: #1d1b16; --muted: #6f6a5f; --ground: #f4f1ea; --line: #ddd7ca; --accent: #2f5bd3; }
+  @media (prefers-color-scheme: dark) { :root { --ink: #ece8df; --muted: #a39d90; --ground: #1c1b18; --line: #34322c; --accent: #8fb0ff; } }
+  html, body { margin: 0; height: 100%; background: var(--ground); color: var(--ink); font: 13px/1.3 system-ui, -apple-system, "Segoe UI", sans-serif; }
+  body { display: flex; flex-direction: column; }
+  #bar { display: flex; align-items: center; gap: 8px; padding: 6px 10px; border-bottom: 1px solid var(--line); flex: none; }
+  #bar[hidden] { display: none; }
+  #name { font-weight: 600; white-space: nowrap; }
+  #sel { font: inherit; color: inherit; background: transparent; border: 1px solid var(--line); border-radius: 6px; padding: 3px 6px; max-width: 46ch; }
+  button { font: inherit; color: inherit; background: transparent; border: 1px solid var(--line); border-radius: 6px; padding: 3px 10px; cursor: pointer; }
+  button:hover { border-color: var(--accent); }
+  button[hidden] { display: none; }
+  #status { color: var(--muted); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  #spacer { flex: 1; }
+  #deck { flex: 1; width: 100%; border: 0; background: #fff; }
+</style>
+</head>
+<body>
+<div id="bar" role="toolbar" aria-label="Versions">
+  <span id="name">Slideless</span>
+  <select id="sel" aria-label="What to show"></select>
+  <button id="back" type="button" hidden>Back to live</button>
+  <span id="spacer"></span>
+  <span id="status" role="status" aria-live="polite"></span>
+  <button id="snap" type="button">Save version</button>
+</div>
+<iframe id="deck" title="Deck" sandbox="${VIEWER_IFRAME_SANDBOX}" referrerpolicy="no-referrer"></iframe>
+<script nonce="${nonce}">
+(() => {
+  const ENTRY_URL = ${entryUrl};
+  const ENTRY = ${entry};
+  const params = new URLSearchParams(location.search);
+  const bar = document.getElementById('bar');
+  const sel = document.getElementById('sel');
+  const back = document.getElementById('back');
+  const snap = document.getElementById('snap');
+  const status = document.getElementById('status');
+  const frame = document.getElementById('deck');
+  if (params.get('bar') === '0') bar.hidden = true;
+
+  let versions = [];
+  let mode = params.get('v') || 'live';
+  if (mode !== 'live' && mode !== 'latest' && !/^[1-9][0-9]*$/.test(mode)) mode = 'live';
+  let shown = null;
+  // Until the first answer of the versions route, a ?v= mode cannot be
+  // checked: it is kept as asked, never dropped to live.
+  let loaded = false;
+  let versionsOff = false;
+
+  const entryOf = (n) => {
+    const v = versions.find((x) => x.version === n);
+    return v ? v.entryPath : ENTRY;
+  };
+  const versionUrl = (n) =>
+    '/__slideless/v/' + n + '/' + entryOf(n).split('/').map(encodeURIComponent).join('/');
+  const target = () => {
+    if (mode === 'live') return ENTRY_URL;
+    const n = mode === 'latest' ? (versions.length ? versions[versions.length - 1].version : null) : Number(mode);
+    return n ? versionUrl(n) : ENTRY_URL;
+  };
+  const show = (force) => {
+    const url = target();
+    if (force || url !== shown) {
+      shown = url;
+      frame.src = url;
+    }
+  };
+  const when = (iso) => {
+    const d = new Date(iso);
+    return isNaN(d) ? '' : d.toLocaleString([], { day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit' });
+  };
+  const render = () => {
+    sel.textContent = '';
+    const add = (value, text) => {
+      const o = document.createElement('option');
+      o.value = value;
+      o.text = text;
+      sel.add(o);
+    };
+    add('live', 'Live: the working folder');
+    // Latest stays a choice with no version yet: it shows the live folder
+    // until the first one is saved, then moves to it. With versions off
+    // there is no latest to wait for.
+    if (!versionsOff) add('latest', versions.length ? 'Latest version (v' + versions[versions.length - 1].version + ')' : 'Latest version (none saved yet)');
+    for (let i = versions.length - 1; i >= 0; i--) {
+      const v = versions[i];
+      add(String(v.version), 'v' + v.version + ' \xB7 ' + when(v.createdAt) + ' \xB7 ' + v.fileCount + (v.fileCount === 1 ? ' file' : ' files'));
+    }
+    if (loaded && ![...sel.options].some((o) => o.value === mode)) {
+      mode = 'live';
+      remember();
+    }
+    if (!loaded && mode !== 'live' && ![...sel.options].some((o) => o.value === mode)) {
+      const o = document.createElement('option');
+      o.value = mode;
+      o.text = mode === 'latest' ? 'Latest version' : 'v' + mode;
+      sel.add(o);
+    }
+    sel.value = mode;
+    back.hidden = mode === 'live';
+  };
+  const remember = () => {
+    const p = new URLSearchParams(location.search);
+    if (mode === 'live') p.delete('v');
+    else p.set('v', mode);
+    const q = p.toString();
+    history.replaceState(null, '', location.pathname + (q ? '?' + q : ''));
+  };
+  const load = async () => {
+    try {
+      const res = await fetch('/__slideless/versions', { cache: 'no-store' });
+      const body = await res.json();
+      versions = Array.isArray(body.versions) ? body.versions : [];
+      versionsOff = Boolean(body.error);
+      if (body.error) {
+        snap.hidden = true;
+        status.textContent = 'Versions unavailable';
+        status.title = body.error;
+      }
+    } catch {
+      versions = [];
+    }
+    loaded = true;
+    render();
+    show(false);
+  };
+  sel.addEventListener('change', () => {
+    mode = sel.value;
+    back.hidden = mode === 'live';
+    remember();
+    show(false);
+  });
+  back.addEventListener('click', () => {
+    mode = 'live';
+    sel.value = 'live';
+    back.hidden = true;
+    remember();
+    show(false);
+  });
+  snap.addEventListener('click', async () => {
+    snap.disabled = true;
+    try {
+      const res = await fetch('/__slideless/snapshot', { method: 'POST', headers: { 'x-slideless': 'snapshot' } });
+      const body = await res.json();
+      if (!res.ok) status.textContent = body.error || 'Could not save a version';
+      else status.textContent = body.created ? 'Saved as v' + body.version : 'No change since v' + body.version;
+    } catch {
+      status.textContent = 'Could not save a version';
+    } finally {
+      snap.disabled = false;
+    }
+  });
+  const connect = () => {
+    const es = new EventSource('/__slideless/reload');
+    es.addEventListener('reload', () => {
+      if (mode === 'live' || (mode === 'latest' && versions.length === 0)) show(true);
+    });
+    es.addEventListener('versions', () => {
+      void load();
+    });
+    es.onerror = () => {
+      es.close();
+      setTimeout(connect, 1000);
+    };
+  };
+  render();
+  if (mode === 'live') show(true);
+  void load();
+  connect();
+})();
+</script>
+</body>
+</html>
+`;
+}
 async function startDevServer(options) {
-  const root = await realpath2(resolve4(options.root));
+  const root = await realpath3(resolve5(options.root));
   const host = options.host ?? "127.0.0.1";
   const sseClients = /* @__PURE__ */ new Set();
   let allowed = /* @__PURE__ */ new Set();
+  let store = null;
+  let storeError = null;
+  let subject = root;
+  try {
+    const opened = await openLocalStore(options.target ?? root, options.store);
+    store = opened.store;
+    subject = opened.root;
+  } catch (err) {
+    storeError = err.message;
+  }
+  const broadcast = (event2) => {
+    for (const client of sseClients) client.write(`event: ${event2}
+data: now
+
+`);
+  };
+  let queue = Promise.resolve();
+  const snapshotNow = () => {
+    const run2 = queue.then(async () => {
+      if (store === null) throw new Error(storeError ?? "Local versions are unavailable");
+      const result = await snapshot(subject, { store, entry: options.entryPath });
+      if (result.created) broadcast("versions");
+      return result;
+    });
+    queue = run2.catch(() => void 0);
+    return run2;
+  };
+  const sameOrigin = (req) => {
+    const origin = req.headers.origin;
+    if (origin === void 0) return true;
+    try {
+      const url2 = new URL(origin);
+      return url2.protocol === "http:" && allowed.has(url2.host.toLowerCase());
+    } catch {
+      return false;
+    }
+  };
+  const serveVersionFile = async (res, n, relPath, head) => {
+    if (store === null) {
+      res.writeHead(404, CONTENT_HEADERS).end("Not found");
+      return;
+    }
+    const record2 = await readLocalVersion(store, subject, n);
+    const wanted = relPath === "" ? record2?.entryPath : relPath;
+    const file2 = record2?.manifest.find((f) => f.path === wanted);
+    if (!record2 || !file2) {
+      res.writeHead(404, CONTENT_HEADERS).end("Not found");
+      return;
+    }
+    const blob = blobPath(store, file2.sha256);
+    const info = await stat4(blob).catch(() => null);
+    if (!info?.isFile()) {
+      res.writeHead(404, CONTENT_HEADERS).end("Not found");
+      return;
+    }
+    const type = file2.contentType === "text/html" ? "text/html; charset=utf-8" : file2.contentType;
+    res.writeHead(200, { ...CONTENT_HEADERS, "content-type": type, "content-length": String(info.size) });
+    if (head) {
+      res.end();
+      return;
+    }
+    await new Promise((done, fail) => {
+      const stream = createReadStream3(blob);
+      stream.on("error", fail);
+      res.on("close", () => {
+        stream.destroy();
+        done();
+      });
+      stream.pipe(res).on("finish", () => done());
+    });
+  };
   const server = createServer((req, res) => {
     void (async () => {
       if (!hostAllowed(req, allowed)) {
@@ -33982,10 +34492,50 @@ async function startDevServer(options) {
         res.writeHead(400, CONTENT_HEADERS).end("Bad request");
         return;
       }
+      const method = req.method ?? "GET";
+      if (pathname === SNAPSHOT_PATH) {
+        if (method !== "POST") {
+          res.writeHead(405, { ...PLAIN_HEADERS, allow: "POST" }).end("Method not allowed");
+          return;
+        }
+        if (req.headers[SNAPSHOT_HEADER] !== SNAPSHOT_HEADER_VALUE || !sameOrigin(req)) {
+          json2(res, 403, { error: "forbidden" });
+          return;
+        }
+        try {
+          const result = await snapshotNow();
+          json2(res, result.created ? 201 : 200, {
+            version: result.version,
+            created: result.created,
+            entryPath: result.entryPath,
+            fileCount: result.fileCount,
+            sizeBytes: result.sizeBytes
+          });
+        } catch (err) {
+          json2(res, 409, { error: err.message });
+        }
+        return;
+      }
+      if (method !== "GET" && method !== "HEAD") {
+        res.writeHead(405, { ...CONTENT_HEADERS, allow: "GET, HEAD" }).end("Method not allowed");
+        return;
+      }
+      const head = method === "HEAD";
+      if (pathname === "/") {
+        const nonce = randomBytes2(16).toString("base64");
+        res.writeHead(200, {
+          ...PLAIN_HEADERS,
+          "content-security-policy": wrapperCsp(nonce),
+          "content-type": "text/html; charset=utf-8"
+        });
+        res.end(head ? void 0 : wrapperHtml(nonce, options.entryPath));
+        return;
+      }
       if (pathname === RELOAD_PATH) {
         res.writeHead(200, {
           "content-type": "text/event-stream",
           "cache-control": "no-store",
+          "x-content-type-options": "nosniff",
           connection: "keep-alive"
         });
         res.write(": connected\n\n");
@@ -33993,25 +34543,43 @@ async function startDevServer(options) {
         req.on("close", () => sseClients.delete(res));
         return;
       }
-      const relPath = pathname === "/" ? options.entryPath : pathname.replace(/^\/+/, "");
+      if (pathname === VERSIONS_PATH) {
+        const versions = store === null ? [] : await listLocalVersions(store, subject);
+        json2(res, 200, {
+          cli: options.cliVersion ?? null,
+          entry: options.entryPath,
+          versions: versions.map(({ root: _root, ...v }) => v),
+          ...storeError ? { error: storeError } : {}
+        });
+        return;
+      }
+      const versionFile = VERSION_FILE_RE.exec(pathname);
+      if (versionFile) {
+        await serveVersionFile(res, Number(versionFile[1]), versionFile[2], head);
+        return;
+      }
+      if (pathname.startsWith(DEV_ROUTE_PREFIX)) {
+        res.writeHead(404, CONTENT_HEADERS).end("Not found");
+        return;
+      }
+      const relPath = pathname.replace(/^\/+/, "");
       const target = await resolveServable(root, relPath);
       if (target === null) {
         res.writeHead(404, CONTENT_HEADERS).end("Not found");
         return;
       }
-      const info = await stat3(target).catch(() => null);
+      const info = await stat4(target).catch(() => null);
       if (!info || !info.isFile()) {
         res.writeHead(404, CONTENT_HEADERS).end("Not found");
         return;
       }
       const contentType = contentTypeFor(target);
-      if (contentType === "text/html") {
-        const html = injectReload(await readFile5(target, "utf8"));
-        res.writeHead(200, { ...CONTENT_HEADERS, "content-type": "text/html; charset=utf-8" }).end(html);
-        return;
-      }
-      const bytes = await readFile5(target);
-      res.writeHead(200, { ...CONTENT_HEADERS, "content-type": contentType }).end(bytes);
+      const bytes = await readFile6(target);
+      res.writeHead(200, {
+        ...CONTENT_HEADERS,
+        "content-type": contentType === "text/html" ? "text/html; charset=utf-8" : contentType
+      });
+      res.end(head ? void 0 : bytes);
     })().catch(() => {
       if (!res.headersSent) res.writeHead(500, CONTENT_HEADERS);
       res.end("Internal error");
@@ -34019,21 +34587,45 @@ async function startDevServer(options) {
   });
   let watcher = null;
   let debounce = null;
-  const broadcast = () => {
+  const onChange = (_event, filename) => {
+    const name = filename === null ? "" : filename.toString();
+    if (name && name.split(/[\\/]/).some((seg) => seg.startsWith("."))) return;
     if (debounce) clearTimeout(debounce);
-    debounce = setTimeout(() => {
-      for (const client of sseClients) client.write("event: reload\ndata: now\n\n");
-    }, 100);
+    debounce = setTimeout(() => broadcast("reload"), 100);
   };
   try {
-    watcher = watch(root, { recursive: true }, broadcast);
+    watcher = watch(root, { recursive: true }, onChange);
   } catch {
     try {
-      watcher = watch(root, broadcast);
+      watcher = watch(root, onChange);
     } catch {
       watcher = null;
     }
   }
+  watcher?.on("error", () => {
+    watcher?.close();
+    watcher = null;
+  });
+  let storeWatcher = null;
+  let storeDebounce = null;
+  if (store !== null) {
+    const dir = localVersionsDir(store, subject);
+    try {
+      await mkdir4(dir, { recursive: true });
+      storeWatcher = watch(dir, (_event, filename) => {
+        const name = filename === null ? "" : filename.toString();
+        if (name && !/^[1-9][0-9]*\.json$/.test(name)) return;
+        if (storeDebounce) clearTimeout(storeDebounce);
+        storeDebounce = setTimeout(() => broadcast("versions"), 100);
+      });
+      storeWatcher.on("error", () => {
+        storeWatcher?.close();
+        storeWatcher = null;
+      });
+    } catch {
+      storeWatcher = null;
+    }
+  }
   await new Promise((resolvePromise, reject) => {
     server.once("error", reject);
     server.listen(options.port, host, () => {
@@ -34047,9 +34639,14 @@ async function startDevServer(options) {
   return {
     url: `http://${host}:${port}/`,
     port,
+    store,
+    storeError,
+    snapshot: snapshotNow,
     close: async () => {
       watcher?.close();
+      storeWatcher?.close();
       if (debounce) clearTimeout(debounce);
+      if (storeDebounce) clearTimeout(storeDebounce);
       for (const client of sseClients) client.end();
       sseClients.clear();
       await new Promise((resolvePromise) => server.close(() => resolvePromise()));
@@ -34065,8 +34662,8 @@ function shouldOpenAfterPush(input2) {
 }
 
 // src/commands/projects.ts
-import { stat as stat4 } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { stat as stat5 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
 function projectsGroup(program2) {
   const group = program2.commands.find((c) => c.name() === "projects");
   if (!group) {
@@ -34076,7 +34673,7 @@ function projectsGroup(program2) {
 }
 async function isFolder(path) {
   try {
-    return (await stat4(path)).isDirectory();
+    return (await stat5(path)).isDirectory();
   } catch {
     return false;
   }
@@ -34084,12 +34681,12 @@ async function isFolder(path) {
 async function resolveDeck(ctx, deck) {
   if (deck !== void 0) {
     if (isDeckId(deck)) return deck;
-    if (!await isFolder(resolve5(deck))) {
+    if (!await isFolder(resolve6(deck))) {
       throw new CliUsageError(
         `${deck} is neither a deck id nor a folder. Name the deck by id, or by a folder a push linked.`
       );
     }
-    const linked2 = await linkedDeckId(ctx, resolve5(deck), "Name the deck by id instead.");
+    const linked2 = await linkedDeckId(ctx, resolve6(deck), "Name the deck by id instead.");
     if (!linked2) {
       throw new CliUsageError(
         `No ${LINK_FILENAME} in ${deck} \u2014 push that folder first, or name the deck by id.`
@@ -34097,7 +34694,7 @@ async function resolveDeck(ctx, deck) {
     }
     return linked2;
   }
-  const linked = await linkedDeckId(ctx, resolve5("."), "Name the deck by id instead.");
+  const linked = await linkedDeckId(ctx, resolve6("."), "Name the deck by id instead.");
   if (!linked) {
     throw new CliUsageError(
       `No deck given and no ${LINK_FILENAME} in the current folder \u2014 name the deck by id, or run this from a folder a push linked.`
@@ -34213,7 +34810,7 @@ function registerProjectDeckCommands(program2, io) {
       io.out.write(brandLines(current.brand));
       return;
     }
-    const linked = await isFolder(resolve5(ref)) ? await linkedDeckId(ctx, resolve5(ref), "Name the brand by id or title instead.") : null;
+    const linked = await isFolder(resolve6(ref)) ? await linkedDeckId(ctx, resolve6(ref), "Name the brand by id or title instead.") : null;
     const deckId = linked ?? resolveReference(await listReferences(ctx, "brand"), ref, "brand").id;
     const set2 = await explainedDeckProject("brand", () => ctx.client.setProjectBrand(project, deckId));
     if (ctx.json) return printJson2(io, set2);
@@ -34268,7 +34865,7 @@ async function detectFormNames(scan) {
     const names = /* @__PURE__ */ new Set();
     for (const file2 of scan.files) {
       if (file2.contentType !== "text/html" && file2.contentType !== "text/javascript") continue;
-      const html = await readFile6(file2.absPath, "utf8");
+      const html = await readFile7(file2.absPath, "utf8");
       for (const match of html.matchAll(FORM_NAME_RE)) names.add(match[1]);
     }
     return [...names];
@@ -34299,7 +34896,7 @@ async function uploadMissing(ctx, scan) {
   const workers = Array.from({ length: Math.min(UPLOAD_CONCURRENCY, queue.length) }, async () => {
     while (index < queue.length) {
       const file2 = queue[index++];
-      const bytes = await readFile6(file2.absPath);
+      const bytes = await readFile7(file2.absPath);
       await ctx.client.uploadAsset(file2.sha256, new Uint8Array(bytes), file2.contentType);
     }
   });
@@ -34323,21 +34920,21 @@ function registerContentCommands(program2, io) {
     printPushResult(ctx, result, opts);
   });
   program2.command("open [path]").description(`Open the linked deck's page in the browser (reads ${LINK_FILENAME}; --json prints the URL)`).action(async (path, _opts, cmd) => {
-    const { json: json2 } = resolveContextForDev(cmd, io);
-    const rootDir = resolve6(path ?? ".");
-    const link = await readLink(rootDir);
-    if (!link) {
+    const { json: json3 } = resolveContextForDev(cmd, io);
+    const rootDir = resolve7(path ?? ".");
+    const link2 = await readLink(rootDir);
+    if (!link2) {
       throw new CliUsageError(
         `No ${LINK_FILENAME} in ${rootDir} \u2014 push the folder once (\`slideless push\`) to link it to a deck.`
       );
     }
-    if (!isHttpUrl(link.baseUrl)) {
+    if (!isHttpUrl(link2.baseUrl)) {
       throw new CliUsageError(
-        `${LINK_FILENAME} names ${JSON.stringify(link.baseUrl)} as the instance, which is not an http(s) URL \u2014 refusing to open it. Fix the file or push the folder again.`
+        `${LINK_FILENAME} names ${JSON.stringify(link2.baseUrl)} as the instance, which is not an http(s) URL \u2014 refusing to open it. Fix the file or push the folder again.`
       );
     }
-    const url2 = deckMasterUrl(link.baseUrl, link.presentationId);
-    if (json2) return printJson2(io, { presentationId: link.presentationId, baseUrl: link.baseUrl, url: url2 });
+    const url2 = deckMasterUrl(link2.baseUrl, link2.presentationId);
+    if (json3) return printJson2(io, { presentationId: link2.presentationId, baseUrl: link2.baseUrl, url: url2 });
     io.out.write(`${url2}
 `);
     openInBrowser(io, url2);
@@ -34347,13 +34944,13 @@ function registerContentCommands(program2, io) {
     await requireApiKey(ctx);
     let deckId = id2 ?? null;
     if (!deckId) {
-      const link = await readLink(resolve6("."));
-      if (!link) {
+      const link2 = await readLink(resolve7("."));
+      if (!link2) {
         throw new CliUsageError(
           `No deck id given and no ${LINK_FILENAME} found \u2014 run \`slideless agent-doc <id>\`.`
         );
       }
-      deckId = link.presentationId;
+      deckId = link2.presentationId;
     }
     let content;
     try {
@@ -34367,9 +34964,9 @@ function registerContentCommands(program2, io) {
       throw e;
     }
     if (opts.out) {
-      const target = resolve6(opts.out);
-      await mkdir3(dirname4(target), { recursive: true });
-      await writeFile3(target, content);
+      const target = resolve7(opts.out);
+      await mkdir5(dirname5(target), { recursive: true });
+      await writeFile4(target, content);
       if (ctx.json) return printJson2(io, { presentationId: deckId, path: target });
       io.out.write(`Wrote ${AGENT_DOC_PATH} of ${deckId} \u2192 ${target}
 `);
@@ -34390,25 +34987,25 @@ function registerContentCommands(program2, io) {
     let deckId = id2 ?? null;
     let dest = path ?? null;
     if (!deckId) {
-      const link = await readLink(resolve6(dest ?? "."));
-      if (!link) {
+      const link2 = await readLink(resolve7(dest ?? "."));
+      if (!link2) {
         throw new CliUsageError(
           `No deck id given and no ${LINK_FILENAME} found \u2014 run \`slideless pull <id> [path]\`.`
         );
       }
-      if (link.baseUrl !== ctx.baseUrl) throw linkMismatch(link.baseUrl);
-      deckId = link.presentationId;
+      if (link2.baseUrl !== ctx.baseUrl) throw linkMismatch(link2.baseUrl);
+      deckId = link2.presentationId;
       dest = dest ?? ".";
     }
     dest = dest ?? deckId;
     {
-      const link = await readLink(resolve6(dest));
-      if (link && link.baseUrl !== ctx.baseUrl) throw linkMismatch(link.baseUrl);
+      const link2 = await readLink(resolve7(dest));
+      if (link2 && link2.baseUrl !== ctx.baseUrl) throw linkMismatch(link2.baseUrl);
     }
     const deck = await ctx.client.presentation(deckId);
     const version2 = opts.at ?? deck.currentVersion;
     if (version2 < 1) throw new CliUsageError("This deck has no committed versions yet.");
-    const destRoot = resolve6(dest);
+    const destRoot = resolve7(dest);
     const detail = await downloadVersionInto(ctx, deckId, version2, destRoot);
     await writeLink(destRoot, { presentationId: deckId, baseUrl: ctx.baseUrl });
     if (ctx.json) {
@@ -34431,11 +35028,11 @@ function registerContentCommands(program2, io) {
       await requireApiKey(ctx);
       let deckId = id2 ?? null;
       if (!deckId) {
-        const link = await readLink(resolve6("."));
-        if (!link) {
+        const link2 = await readLink(resolve7("."));
+        if (!link2) {
           throw new CliUsageError(`No deck id given and no ${LINK_FILENAME} in the current folder.`);
         }
-        deckId = link.presentationId;
+        deckId = link2.presentationId;
       }
       if (opts.status && opts.status !== "open" && opts.status !== "resolved") {
         throw new CliUsageError("--status must be open or resolved");
@@ -34455,7 +35052,7 @@ function registerContentCommands(program2, io) {
         cursor = page.nextCursor;
       } while (cursor);
       if (opts.out) {
-        await writeFile3(resolve6(opts.out), `${JSON.stringify(rows, null, 2)}
+        await writeFile4(resolve7(opts.out), `${JSON.stringify(rows, null, 2)}
 `);
       }
       if (ctx.json) return printJson2(io, { annotations: rows });
@@ -34486,8 +35083,11 @@ function registerContentCommands(program2, io) {
     (id2, annotationId, _opts, cmd) => setAnnotationStatus(cmd, io, id2, annotationId, "open")
   );
   program2.command("dev [path]").description(
-    "Serve the deck folder locally with the exact viewer sandbox headers + live reload (no backend)"
-  ).option("--port <n>", "port to serve on", (v) => parseInt(v, 10), 4173).option("--entry <path>", "entry document (default: index.html, or the only .html)").option("--no-open", "do not open the browser").action(
+    "Serve the deck folder locally under a version bar, with the exact viewer sandbox headers + live reload (no backend)"
+  ).option("--port <n>", "port to serve on", (v) => parseInt(v, 10), 4173).option("--entry <path>", "entry document (default: index.html, or the only .html)").option(
+    "--store <dir>",
+    `where local versions are kept (default: $${LOCAL_STORE_ENV}, else the user data folder)`
+  ).option("--no-open", "do not open the browser").action(
     async (path, opts, cmd) => {
       const ctx = resolveContextForDev(cmd, io);
       const target = path ?? ".";
@@ -34496,16 +35096,29 @@ function registerContentCommands(program2, io) {
       const server = await startDevServer({
         root: scan.rootDir,
         entryPath,
-        port: opts.port
+        port: opts.port,
+        target,
+        ...opts.store !== void 0 ? { store: opts.store } : {},
+        cliVersion: cliVersionOf(cmd)
       });
       if (ctx.json) {
-        io.out.write(`${JSON.stringify({ url: server.url, entry: entryPath })}
-`);
+        io.out.write(
+          `${JSON.stringify({
+            url: server.url,
+            entry: entryPath,
+            store: server.store,
+            storeError: server.storeError,
+            cli: cliVersionOf(cmd)
+          })}
+`
+        );
       } else {
         io.out.write(
           `Serving ${scan.rootDir} at ${server.url} (entry: ${entryPath})
 Live reload on; sandbox headers match the public viewer. Ctrl-C to stop.
-`
+` + (server.store ? `Local versions in ${server.store}; save one from the bar or with \`slideless snapshot\`.
+` : `Local versions are off: ${server.storeError ?? "no store"}
+`)
         );
       }
       if (opts.open) openInBrowser(io, server.url);
@@ -34518,6 +35131,62 @@ Live reload on; sandbox headers match the public viewer. Ctrl-C to stop.
       });
     }
   );
+  program2.command("snapshot [path]").description(
+    "Save the folder as a new local version on this machine (no instance, no login); no change, no version"
+  ).option("--entry <path>", "entry document (default: index.html, or the only .html)").option(
+    "--store <dir>",
+    `where local versions are kept (default: $${LOCAL_STORE_ENV}, else the user data folder)`
+  ).action(async (path, opts, cmd) => {
+    const ctx = resolveContextForDev(cmd, io);
+    const result = await snapshot(path ?? ".", {
+      ...opts.entry !== void 0 ? { entry: opts.entry } : {},
+      ...opts.store !== void 0 ? { store: opts.store } : {}
+    });
+    if (ctx.json) {
+      io.out.write(`${JSON.stringify(result)}
+`);
+      return;
+    }
+    io.out.write(
+      result.created ? `Saved ${result.root} as local version ${result.version} (${result.fileCount} file${result.fileCount === 1 ? "" : "s"}, ${formatBytes(result.sizeBytes)})
+` : `No change since local version ${result.version} of ${result.root}
+`
+    );
+  });
+  program2.command("snapshots [path]").description("List the local versions of a folder, oldest first").option(
+    "--store <dir>",
+    `where local versions are kept (default: $${LOCAL_STORE_ENV}, else the user data folder)`
+  ).action(async (path, opts, cmd) => {
+    const ctx = resolveContextForDev(cmd, io);
+    const { root, store, exists } = await openLocalStore(path ?? ".", opts.store, { create: false });
+    const versions = exists ? await listLocalVersions(store, root) : [];
+    if (ctx.json) {
+      io.out.write(`${JSON.stringify({ root, store, versions })}
+`);
+      return;
+    }
+    if (versions.length === 0) {
+      io.out.write(`No local versions of ${root} yet: \`slideless snapshot\` saves one.
+`);
+      return;
+    }
+    for (const v of versions) {
+      io.out.write(
+        `v${v.version}  ${v.createdAt}  ${v.fileCount} file${v.fileCount === 1 ? "" : "s"}  ${formatBytes(v.sizeBytes)}  ${v.entryPath}
+`
+      );
+    }
+  });
+}
+function cliVersionOf(cmd) {
+  let top = cmd;
+  while (top.parent) top = top.parent;
+  return top.version();
+}
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
 }
 async function pushDeck(ctx, target, opts) {
   const scan = await scanDeck(target);
@@ -34525,9 +35194,9 @@ async function pushDeck(ctx, target, opts) {
   const manifest = toManifest(scan);
   const totalBytes = scan.files.reduce((sum, f) => sum + f.sizeBytes, 0);
   const attachments = attachmentsOfScan(scan);
-  const link = await readLink(scan.rootDir);
+  const link2 = await readLink(scan.rootDir);
   let existingId = opts.id ?? null;
-  if (!existingId && !opts.new && link) {
+  if (!existingId && !opts.new && link2) {
     existingId = await linkedDeckId(
       ctx,
       scan.rootDir,
@@ -34664,23 +35333,23 @@ async function resolveProvenance(ctx, rootDir, opts) {
       out.push({ type, id: match.id, version: pinned });
       continue;
     }
-    const link = await readReferenceLink(referenceDirFor(rootDir, type));
-    if (!link) continue;
-    if (link.reference.type !== type) {
+    const link2 = await readReferenceLink(referenceDirFor(rootDir, type));
+    if (!link2) continue;
+    if (link2.reference.type !== type) {
       ctx.io.err.write(
-        `Note: the folder ${REFERENCE_DIR}/${type}/ holds a ${link.reference.type}, not a ${type}; it is not recorded on this deck.
+        `Note: the folder ${REFERENCE_DIR}/${type}/ holds a ${link2.reference.type}, not a ${type}; it is not recorded on this deck.
 `
       );
       continue;
     }
-    if (link.baseUrl !== ctx.baseUrl) {
+    if (link2.baseUrl !== ctx.baseUrl) {
       ctx.io.err.write(
-        `Note: the ${type} in ${REFERENCE_DIR}/${type}/ was pulled from ${link.baseUrl}, not ${ctx.baseUrl}; it is not recorded on this deck.
+        `Note: the ${type} in ${REFERENCE_DIR}/${type}/ was pulled from ${link2.baseUrl}, not ${ctx.baseUrl}; it is not recorded on this deck.
 `
       );
       continue;
     }
-    out.push({ type, id: link.presentationId, version: link.reference.version });
+    out.push({ type, id: link2.presentationId, version: link2.reference.version });
   }
   return out;
 }
@@ -34767,7 +35436,7 @@ function printPushResult(ctx, result, opts) {
     created ? `Created "${committed.presentation.title}" at version 1 (${scan.files.length} files, ${fmtBytes(totalBytes)}, ${uploaded} uploaded)
   id: ${committed.presentation.id}
   url: ${url2}
-  linked: ${join5(scan.rootDir, LINK_FILENAME)}
+  linked: ${join6(scan.rootDir, LINK_FILENAME)}
 ` : `Pushed "${committed.presentation.title}" \u2192 version ${committed.version.version} (${scan.files.length} files, ${fmtBytes(totalBytes)}, ${uploaded} uploaded)
   id: ${committed.presentation.id}
   url: ${url2}
@@ -34781,8 +35450,8 @@ function printPushResult(ctx, result, opts) {
   const inProjects = projectsOf(committed.presentation);
   if (inProjects.length > 0) io.out.write(`  projects: ${projectsLine(inProjects)}
 `);
-  for (const link of projectLinks) {
-    if (!link.linked) ctx.io.err.write(`  project ${link.projectId}: ${link.error}
+  for (const link2 of projectLinks) {
+    if (!link2.linked) ctx.io.err.write(`  project ${link2.projectId}: ${link2.error}
 `);
   }
   if (!committed.version.hasAgentDoc) io.out.write(AGENT_DOC_HINT);
@@ -34790,7 +35459,7 @@ function printPushResult(ctx, result, opts) {
 }
 async function downloadVersionInto(ctx, deckId, version2, destRoot) {
   const detail = await ctx.client.presentationVersion(deckId, version2);
-  await mkdir3(destRoot, { recursive: true });
+  await mkdir5(destRoot, { recursive: true });
   for (const entry of detail.manifest) {
     if (!isSafeAssetPath(entry.path)) {
       throw new Error(`Refusing to write unsafe manifest path: ${entry.path}`);
@@ -35007,11 +35676,11 @@ ${JSON.stringify(updated.metadata, null, 2)}
 }
 
 // src/commands/references.ts
-import { mkdir as mkdir4, readdir as readdir2, readFile as readFile8, rm, rmdir, stat as stat5 } from "node:fs/promises";
-import { dirname as dirname5, join as join6, resolve as resolve7 } from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile9, rm as rm2, rmdir, stat as stat6 } from "node:fs/promises";
+import { dirname as dirname6, join as join7, resolve as resolve8 } from "node:path";
 
 // src/commands/documents.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 var collect5 = (value, all) => [...all, value];
 function registerTemplateSchemaCommands(root, io) {
   const schema = root.command("schema").description(
@@ -35233,7 +35902,7 @@ async function resolveTemplate(ctx, ref) {
 async function readJsonObject(path, flag) {
   let text;
   try {
-    text = await readFile7(path, "utf8");
+    text = await readFile8(path, "utf8");
   } catch {
     throw new CliUsageError(`${flag}: cannot read ${path}.`);
   }
@@ -35368,7 +36037,7 @@ function registerFamily(program2, io, family) {
       const match = await pickReference(ctx, ref, type, noun);
       const matchType = match.reference.type;
       const version2 = versionOf(match, opts.at);
-      const dest = resolve7(opts.into ?? referenceDirFor(".", matchType));
+      const dest = resolve8(opts.into ?? referenceDirFor(".", matchType));
       await prepareReferenceDir(dest, ctx.baseUrl, noun);
       const detail = await downloadOrClean(ctx, match.id, version2, dest);
       await writeLink(dest, {
@@ -35386,7 +36055,7 @@ function registerFamily(program2, io, family) {
       }
       io.out.write(
         `Pulled ${matchType} "${match.title}" v${version2} \u2192 ${dest} (${detail.manifest.length} files)
-  read ${join6(dest, AGENT_DOC_PATH)} before authoring; a push from the deck folder records this ${matchType}.
+  read ${join7(dest, AGENT_DOC_PATH)} before authoring; a push from the deck folder records this ${matchType}.
 `
       );
     }
@@ -35397,18 +36066,18 @@ function registerFamily(program2, io, family) {
     ),
     "the type to scaffold"
   ).option("--title <title>", "the title written in the frontmatter (default: an invented one)").action(async (dir, opts, cmd) => {
-    const { json: json2 } = jsonOnly(cmd);
+    const { json: json3 } = jsonOnly(cmd);
     const type = typeOf(family, opts.type, true);
-    const target = resolve7(dir);
+    const target = resolve8(dir);
     if (!await isMissingOrEmptyDir(target)) {
       throw new CliUsageError(`${target} exists and is not empty; scaffold into a new or empty folder.`);
     }
     const scaffold = scaffoldReference(type, opts.title);
-    await mkdir4(target, { recursive: true });
-    for (const d of scaffold.dirs) await mkdir4(join6(target, d), { recursive: true });
+    await mkdir6(target, { recursive: true });
+    for (const d of scaffold.dirs) await mkdir6(join7(target, d), { recursive: true });
     for (const f of scaffold.files)
-      await writeNoFollow(join6(target, f.path), Buffer.from(f.content, "utf8"));
-    if (json2)
+      await writeNoFollow(join7(target, f.path), Buffer.from(f.content, "utf8"));
+    if (json3)
       return printJson2(io, {
         path: target,
         type,
@@ -35448,7 +36117,7 @@ function registerFamily(program2, io, family) {
       try {
         result = await pushDeck(ctx, target, pushOpts);
       } catch (e) {
-        if (e instanceof PlatformApiError && e.status === 404 && await readReferenceLink(resolve7(target))) {
+        if (e instanceof PlatformApiError && e.status === 404 && await readReferenceLink(resolve8(target))) {
           throw new CliUsageError(
             `This ${noun} is not yours to push: only its owner (or a collaborator with a dev grant) pushes a new version, and the instance answers "not found" to anyone else. Start a deck of your own from it with \`slideless ${family.name} start\`.`
           );
@@ -35539,15 +36208,15 @@ function registerFamily(program2, io, family) {
     const type = typeOf(family, opts.type, false);
     const match = await pickReference(ctx, ref, type, noun);
     const version2 = versionOf(match, opts.at);
-    const target = resolve7(dir);
+    const target = resolve8(dir);
     if (!await isMissingOrEmptyDir(target)) {
       throw new CliUsageError(`${target} exists and is not empty; start into a new or empty folder.`);
     }
     const detail = await downloadOrClean(ctx, match.id, version2, target);
-    const agentPath = join6(target, AGENT_DOC_PATH);
+    const agentPath = join7(target, AGENT_DOC_PATH);
     const hadAgentDoc = detail.manifest.some((e) => e.path === AGENT_DOC_PATH);
     if (hadAgentDoc) {
-      const text = await readFile8(agentPath, "utf8");
+      const text = await readFile9(agentPath, "utf8");
       await writeNoFollow(agentPath, Buffer.from(stripTypeLine(text), "utf8"));
     }
     const from = { type: match.reference.type, id: match.id, version: version2 };
@@ -35615,15 +36284,15 @@ async function patchReference(ctx, match, patch, noun) {
   }
 }
 async function refuseUnlessDeclared(target, type, noun) {
-  const abs = resolve7(target);
-  const info = await stat5(abs).catch(() => null);
+  const abs = resolve8(target);
+  const info = await stat6(abs).catch(() => null);
   if (!info) throw new CliUsageError(`No such file or directory: ${target}`);
   if (!info.isDirectory()) {
     throw new CliUsageError(
       `A ${noun} is a folder with an ${AGENT_DOC_PATH} at its root; ${target} is a file.`
     );
   }
-  const text = await readFile8(join6(abs, AGENT_DOC_PATH), "utf8").catch(() => null);
+  const text = await readFile9(join7(abs, AGENT_DOC_PATH), "utf8").catch(() => null);
   if (text === null) {
     throw new CliUsageError(
       `${target} has no ${AGENT_DOC_PATH}: a ${noun} declares its type in that file's frontmatter (\`slideless ${noun === "reference" ? "reference" : noun} new\` scaffolds one). Nothing was uploaded.`
@@ -35654,41 +36323,41 @@ async function refuseUnlessDeclared(target, type, noun) {
 }
 async function prepareReferenceDir(dest, baseUrl, noun) {
   if (await isMissingOrEmptyDir(dest)) return;
-  const info = await stat5(dest);
+  const info = await stat6(dest);
   if (!info.isDirectory()) throw new CliUsageError(`${dest} exists and is not a folder.`);
-  const link = await readReferenceLink(dest);
-  if (!link) {
+  const link2 = await readReferenceLink(dest);
+  if (!link2) {
     const plain = await readLink(dest);
     throw new CliUsageError(
       plain ? `${dest} is a deck folder linked by ${LINK_FILENAME}, not a pulled ${noun}; pull into another folder (--into).` : `${dest} is not empty and is not a folder a previous pull wrote. Delete it to pull there, or pull into another folder (--into).`
     );
   }
-  if (link.baseUrl !== baseUrl) {
+  if (link2.baseUrl !== baseUrl) {
     throw new CliUsageError(
-      `${dest} holds a ${link.reference.type} pulled from ${link.baseUrl}, and you are pulling from ${baseUrl}. Delete the folder or pull into another one (--into).`
+      `${dest} holds a ${link2.reference.type} pulled from ${link2.baseUrl}, and you are pulling from ${baseUrl}. Delete the folder or pull into another one (--into).`
     );
   }
-  await rm(dest, { recursive: true, force: true });
+  await rm2(dest, { recursive: true, force: true });
 }
 async function downloadOrClean(ctx, deckId, version2, dest) {
   const destExisted = await pathExists(dest);
-  let firstExisting = dirname5(dest);
-  while (firstExisting !== dirname5(firstExisting) && !await pathExists(firstExisting)) {
-    firstExisting = dirname5(firstExisting);
+  let firstExisting = dirname6(dest);
+  while (firstExisting !== dirname6(firstExisting) && !await pathExists(firstExisting)) {
+    firstExisting = dirname6(firstExisting);
   }
   try {
     return await downloadVersionInto(ctx, deckId, version2, dest);
   } catch (e) {
     const removed = [];
     if (destExisted) {
-      for (const entry of await readdir2(dest).catch(() => [])) {
-        await rm(join6(dest, entry), { recursive: true, force: true }).catch(() => void 0);
-        removed.push(join6(dest, entry));
+      for (const entry of await readdir3(dest).catch(() => [])) {
+        await rm2(join7(dest, entry), { recursive: true, force: true }).catch(() => void 0);
+        removed.push(join7(dest, entry));
       }
     } else if (await pathExists(dest)) {
-      await rm(dest, { recursive: true, force: true }).catch(() => void 0);
+      await rm2(dest, { recursive: true, force: true }).catch(() => void 0);
       removed.push(dest);
-      for (let level = dirname5(dest); level !== firstExisting; level = dirname5(level)) {
+      for (let level = dirname6(dest); level !== firstExisting; level = dirname6(level)) {
         try {
           await rmdir(level);
         } catch {
@@ -35706,10 +36375,10 @@ async function downloadOrClean(ctx, deckId, version2, dest) {
   }
 }
 async function isMissingOrEmptyDir(path) {
-  const info = await stat5(path).catch(() => null);
+  const info = await stat6(path).catch(() => null);
   if (!info) return true;
   if (!info.isDirectory()) return false;
-  return (await readdir2(path)).length === 0;
+  return (await readdir3(path)).length === 0;
 }
 function jsonOnly(cmd) {
   const opts = cmd.optsWithGlobals();
@@ -36326,15 +36995,15 @@ function csvCell(raw) {
 }
 
 // src/commands/response-files.ts
-import { createWriteStream as createWriteStream2 } from "node:fs";
-import { stat as stat6, unlink as unlink2 } from "node:fs/promises";
-import { basename as basename3, resolve as resolve8, win32 as win322 } from "node:path";
+import { createWriteStream as createWriteStream3 } from "node:fs";
+import { stat as stat7, unlink as unlink2 } from "node:fs/promises";
+import { basename as basename4, resolve as resolve9, win32 as win322 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
-import { pipeline as pipeline3 } from "node:stream/promises";
+import { pipeline as pipeline4 } from "node:stream/promises";
 var MAX_SEGMENT_CHARS = 120;
 function safePathSegment(raw) {
   const printable = raw.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
-  const name = basename3(win322.basename(printable));
+  const name = basename4(win322.basename(printable));
   const cleaned = truncateKeepingExtension(
     name.replace(/[\\/:*?"<>|]/g, "_").replace(/^\.+/, "_").replace(/[\s.]+$/, ""),
     MAX_SEGMENT_CHARS
@@ -36464,7 +37133,7 @@ function registerResponseFilesCommand(program2, io) {
         } while (cursor);
       }
       const planned = plan(responses, responseId !== void 0);
-      const root = resolve8(
+      const root = resolve9(
         opts.out ?? (responseId !== void 0 ? `response-files-${safePathSegment(responseId.slice(0, 8))}` : `form-files-${safePathSegment(id2.slice(0, 8))}`)
       );
       if (planned.length === 0) {
@@ -36527,21 +37196,21 @@ async function zipMode(ctx, io, id2, responseId, filters, zip) {
   let path;
   let sizeBytes;
   if (typeof zip === "string") {
-    path = resolve8(zip);
+    path = resolve9(zip);
     try {
-      await pipeline3(source, createWriteStream2(path));
+      await pipeline4(source, createWriteStream3(path));
     } catch (e) {
       await unlink2(path).catch(() => void 0);
       throw e;
     }
-    sizeBytes = (await stat6(path)).size;
+    sizeBytes = (await stat7(path)).size;
   } else {
     const served = contentDispositionName(res.headers.get("content-disposition"));
     const fallback = `form-files-${safePathSegment((responseId ?? id2).slice(0, 8))}.zip`;
     let name = served ? safePathSegment(served) : fallback;
     if (name === "_") name = fallback;
     if (!/\.zip$/i.test(name)) name = `${name}.zip`;
-    ({ path, sizeBytes } = await streamContained(resolve8("."), name, source));
+    ({ path, sizeBytes } = await streamContained(resolve9("."), name, source));
   }
   if (ctx.json) return printJson2(io, { mode: "zip", path, sizeBytes });
   io.out.write(`Form files written to ${path} (${fmtBytes(sizeBytes)})
@@ -36549,7 +37218,7 @@ async function zipMode(ctx, io, id2, responseId, filters, zip) {
 }
 
 // src/index.ts
-var VERSION = "0.13.14";
+var VERSION = "0.14.1";
 function registerTool(program2, io) {
   registerDeckCommands(program2, io);
   registerContentCommands(program2, io);