@lotics/cli 0.251.0 → 0.252.0

package/dist/src/cli.js

@@ -52,7 +52,7 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
 var define_LOTICS_KIT_VERSIONS_default;
 var init_define_LOTICS_KIT_VERSIONS = __esm({
   "<define:__LOTICS_KIT_VERSIONS__>"() {
-    define_LOTICS_KIT_VERSIONS_default = { runtime: "0.37.0" };
+    define_LOTICS_KIT_VERSIONS_default = { runtime: "0.37.1" };
   }
 });
 
@@ -2547,20 +2547,20 @@ var require_compiler = __commonJS({
     }
     Compiler.prototype = {
       compiler: Compiler,
-      equals: function equals(other) {
+      equals: function equals(other2) {
         var len = this.opcodes.length;
-        if (other.opcodes.length !== len) {
+        if (other2.opcodes.length !== len) {
           return false;
         }
         for (var i = 0; i < len; i++) {
-          var opcode = this.opcodes[i], otherOpcode = other.opcodes[i];
+          var opcode = this.opcodes[i], otherOpcode = other2.opcodes[i];
           if (opcode.opcode !== otherOpcode.opcode || !argEquals(opcode.args, otherOpcode.args)) {
             return false;
           }
         }
         len = this.children.length;
         for (var i = 0; i < len; i++) {
-          if (!this.children[i].equals(other.children[i])) {
+          if (!this.children[i].equals(other2.children[i])) {
             return false;
           }
         }
@@ -44847,8 +44847,8 @@ var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
     safeExtend(incoming) {
       return util_exports.safeExtend(this, incoming);
     },
-    merge(other) {
-      return util_exports.merge(this, other);
+    merge(other2) {
+      return util_exports.merge(this, other2);
     },
     pick(mask) {
       return util_exports.pick(this, mask);
@@ -51975,6 +51975,13 @@ function generatePrefixedId(prefix) {
 }
 var RECORD_ID_PATTERN = new RegExp(`^rec_[${ID_ALPHABET}]{${ID_LENGTH}}$`);
 var FILE_ID_PATTERN = new RegExp(`^fil_[${ID_ALPHABET}]{${ID_LENGTH}}$`);
+var TABLE_ID_PATTERN = new RegExp(
+  `^tbl_[${ID_ALPHABET}]+$|^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`,
+  "i"
+);
+function isTableId(value) {
+  return TABLE_ID_PATTERN.test(value);
+}
 function generateWorkspaceId() {
   return generatePrefixedId("wsp");
 }
@@ -52000,6 +52007,10 @@ var FIELD_KEY_PREFIX = "fld_";
 function generateFieldKey() {
   return `${FIELD_KEY_PREFIX}${nanoid4()}`;
 }
+var STORED_KEY_PATTERN = /^[A-Za-z0-9_]+$/;
+function isStoredKey(value) {
+  return STORED_KEY_PATTERN.test(value);
+}
 function generateOptionKey() {
   return `opt_${nanoid4()}`;
 }
@@ -52726,9 +52737,9 @@ function unpairableAdoptedLinks(entities, live) {
     for (const field2 of entity.fields) {
       if (field2.type !== "select_record_link") continue;
       if (field2.paired_field_alias === void 0 && field2.sync_both_ways !== true) continue;
-      const held = live.link(entity.alias, field2.alias);
-      if (held === void 0 || held.paired) continue;
-      if (held.target_table !== live.table(field2.target_entity)) continue;
+      const held2 = live.link(entity.alias, field2.alias);
+      if (held2 === void 0 || held2.paired) continue;
+      if (held2.target_table !== live.table(field2.target_entity)) continue;
       found.push({ entity: entity.alias, field: field2.alias });
     }
   }
@@ -52829,15 +52840,15 @@ function selectWordRefusals(entityAlias, expression, fieldByEntity, path39) {
   return parseFieldRefTokens(expression).flatMap((token2) => {
     if (contractOptionRef(token2) !== void 0) return [];
     const field2 = fieldByEntity.get(entityAlias)?.get(token2);
-    const held = field2 === void 0 ? void 0 : formulaSelectOptions(entityAlias, field2, fieldByEntity);
-    const spelled = held?.options.find((option) => words.has(option.label) || words.has(option.alias));
-    if (held === void 0 || spelled === void 0) return [];
+    const held2 = field2 === void 0 ? void 0 : formulaSelectOptions(entityAlias, field2, fieldByEntity);
+    const spelled = held2?.options.find((option) => words.has(option.label) || words.has(option.alias));
+    if (held2 === void 0 || spelled === void 0) return [];
     const word = words.has(spelled.label) ? spelled.label : spelled.alias;
     return [
       {
         severity: "error",
         path: path39,
-        message: held.own ? `compares {${token2}} to "${word}", and a select reaches a formula as the KEYS of its options, never their words \u2014 name the option {${token2}:${spelled.alias}}: includes({${token2}}, {${token2}:${spelled.alias}})` : `compares {${token2}} to "${word}", and a looked-up select reaches a formula as the KEYS of its options, never their words \u2014 test it on "${held.entity}", where the select lives ({field:option} names one there), and look that result up`
+        message: held2.own ? `compares {${token2}} to "${word}", and a select reaches a formula as the KEYS of its options, never their words \u2014 name the option {${token2}:${spelled.alias}}: includes({${token2}}, {${token2}:${spelled.alias}})` : `compares {${token2}} to "${word}", and a looked-up select reaches a formula as the KEYS of its options, never their words \u2014 test it on "${held2.entity}", where the select lives ({field:option} names one there), and look that result up`
       }
     ];
   });
@@ -54151,17 +54162,17 @@ function contactHref(text) {
 function navigatesSections(drawn) {
   return drawn >= 3;
 }
-function offeredTogether(one, other) {
-  const theirs = other.when;
+function offeredTogether(one, other2) {
+  const theirs = other2.when;
   if (one.when === void 0 || theirs === void 0) return false;
-  const shared = one.when.flatMap((held) => {
-    const match2 = theirs.find((candidate) => candidate.field === held.field);
-    return match2 === void 0 ? [] : [held.options.some((option) => match2.options.includes(option))];
+  const shared = one.when.flatMap((held2) => {
+    const match2 = theirs.find((candidate) => candidate.field === held2.field);
+    return match2 === void 0 ? [] : [held2.options.some((option) => match2.options.includes(option))];
   });
   return shared.length > 0 && shared.every(Boolean);
 }
 function isOutcome(act, acts) {
-  return act.to !== void 0 && acts.some((other) => other.alias !== act.alias && other.to !== void 0 && other.of === act.of && offeredTogether(act, other));
+  return act.to !== void 0 && acts.some((other2) => other2.alias !== act.alias && other2.to !== void 0 && other2.of === act.of && offeredTogether(act, other2));
 }
 function isCorrection(act, acts) {
   return act.danger === true && !isOutcome(act, acts);
@@ -54267,11 +54278,11 @@ function actHome(model, app, act) {
   const order = field2?.type === "select" ? (field2.options ?? []).map((option) => option.alias) : [];
   if (typeof moved !== "string" || !order.includes(moved)) return void 0;
   const sections = app.record?.sections ?? [];
-  const held = act.when?.[status];
-  const own = held === void 0 ? -1 : sections.findIndex((section) => held.every((option) => section.at?.includes(option) === true));
+  const held2 = act.when?.[status];
+  const own = held2 === void 0 ? -1 : sections.findIndex((section) => held2.every((option) => section.at?.includes(option) === true));
   const into = sections.findIndex((section) => section.at?.includes(moved) === true);
   const earlier = (from, to) => order.indexOf(from) < order.indexOf(to);
-  const forward = held !== void 0 && held.some((option) => earlier(option, moved));
+  const forward = held2 !== void 0 && held2.some((option) => earlier(option, moved));
   const passed = (stage) => stage.includes(order[0] ?? "") || actsOver(model, app.entity).some((one) => {
     const to = one.set?.[status];
     return typeof to === "string" && stage.includes(to) && (one.when?.[status] ?? []).some((from) => earlier(from, to));
@@ -54378,8 +54389,8 @@ function withEntityLocks(model, app) {
   const merged = /* @__PURE__ */ new Map();
   for (const check2 of [...app.checks ?? [], ...gathered]) {
     const key = `${check2.of ?? ""}|${check2.field}`;
-    const held = merged.get(key);
-    merged.set(key, held === void 0 ? check2 : { ...held, ...unionBlocks(held.blocks, check2.blocks) });
+    const held2 = merged.get(key);
+    merged.set(key, held2 === void 0 ? check2 : { ...held2, ...unionBlocks(held2.blocks, check2.blocks) });
   }
   return [...merged.values()];
 }
@@ -54436,8 +54447,8 @@ function historyShape(model, parent) {
   }
   const parentStatus = entityOf(model, parent)?.fields.find((field2) => field2.alias === status.field);
   if (statusField.type === "select" && parentStatus?.type === "select") {
-    const held = new Set(statusField.options.map((option) => option.alias));
-    const missing = parentStatus.options.filter((option) => !held.has(option.alias)).map((option) => option.alias);
+    const held2 = new Set(statusField.options.map((option) => option.alias));
+    const missing = parentStatus.options.filter((option) => !held2.has(option.alias)).map((option) => option.alias);
     if (missing.length > 0) {
       return { refused: `names history "${history.alias}", whose "${statusField.alias}" lacks the options ${missing.join(", ")} \u2014 a history writes the option the status moved to` };
     }
@@ -54606,11 +54617,11 @@ function checkReading(model, reading, at2) {
     const over = own(reading.over, `${at2}.over`);
     if (over !== void 0 && over.type !== "date") findings.push(error51(`${at2}.over`, `"${reading.over}" is a ${over.type} field \u2014 a reading places its rows in time by a stored date`));
   }
-  for (const [name, held] of Object.entries(reading.where ?? {})) {
+  for (const [name, held2] of Object.entries(reading.where ?? {})) {
     const path39 = `${at2}.where.${name}`;
     const field2 = own(name, path39);
     if (field2 === void 0) continue;
-    if (typeof held === "boolean") {
+    if (typeof held2 === "boolean") {
       if (field2.type !== "boolean") findings.push(error51(path39, `"${name}" is a ${field2.type} field \u2014 true or false keeps rows by a yes/no`));
       continue;
     }
@@ -54619,7 +54630,7 @@ function checkReading(model, reading, at2) {
       continue;
     }
     const declared = new Set(field2.options.map((option) => option.alias));
-    for (const [index, option] of held.entries()) {
+    for (const [index, option] of held2.entries()) {
       if (!declared.has(option)) findings.push(error51(`${path39}.${index}`, `names "${option}", which is not an option of "${name}"`));
     }
   }
@@ -54909,9 +54920,9 @@ function checkInputDefault(model, entity, ask, at2) {
   })();
   return holds ? [] : [error51(at2, `"${name}" is a ${type} field and "${ask.input}" asks a ${ask.type} \u2014 an input starts from a field holding what it states`)];
 }
-function offeredTogether2(one, other) {
+function offeredTogether2(one, other2) {
   return Object.entries(one.when ?? {}).every(([field2, options]) => {
-    const theirs = other.when?.[field2];
+    const theirs = other2.when?.[field2];
     return theirs === void 0 || options.some((option) => theirs.includes(option));
   });
 }
@@ -54988,7 +54999,7 @@ function templateFields(content) {
 // ../shared/src/schemas/app_model_resolve_readings.ts
 init_define_LOTICS_KIT_VERSIONS();
 function whereOf(stated2) {
-  return Object.entries(stated2 ?? {}).map(([field2, held]) => typeof held === "boolean" ? { field: field2, value: held } : { field: field2, options: held });
+  return Object.entries(stated2 ?? {}).map(([field2, held2]) => typeof held2 === "boolean" ? { field: field2, value: held2 } : { field: field2, options: held2 });
 }
 function resolveReading(model, reading, at2) {
   if ("list" in reading) {
@@ -55442,8 +55453,8 @@ function resolveBlock(model, parent, block2, at2) {
       const where = whenOf(block2.where);
       const stating = Array.isArray(stated2) ? stated2 : stated2 === false || !peopleWrite(child) ? [] : defaultCreate(model, child, [link.link]);
       if (stated2 === void 0 && stating.length > 0) defaulted.push(`${at2}.create`);
-      const held = where.map((one) => one.field);
-      const create2 = stating.length === 0 ? [] : block2.expect === void 0 ? unique([...held, ...stating]) : unique([block2.expect, ...held, ...stating, ...expectedColumns(model, child, block2.columns ?? [])]);
+      const held2 = where.map((one) => one.field);
+      const create2 = stating.length === 0 ? [] : block2.expect === void 0 ? unique([...held2, ...stating]) : unique([block2.expect, ...held2, ...stating, ...expectedColumns(model, child, block2.columns ?? [])]);
       return {
         block: {
           kind: "rows",
@@ -55495,19 +55506,19 @@ function blockHeld(model, entity, blocks) {
       (block2) => block2.kind === "rows" || block2.kind === "timeline" ? entity.fields.flatMap((field2) => field2.type === "select_record_link" && field2.target_entity === block2.entity && field2.paired_field_alias === block2.via ? [field2.alias] : []) : []
     )
   );
-  const held = /* @__PURE__ */ new Set([...own, ...links]);
+  const held2 = /* @__PURE__ */ new Set([...own, ...links]);
   for (let grew = true; grew; ) {
     grew = false;
     for (const field2 of entity.fields) {
-      if (held.has(field2.alias)) continue;
+      if (held2.has(field2.alias)) continue;
       const reads = field2.type === "rollup" || field2.type === "lookup" ? [field2.source_field_alias] : field2.type === "formula" ? contractFormulaFieldRefs(field2.formula.expression) : [];
-      if (reads.some((alias2) => held.has(alias2))) {
-        held.add(field2.alias);
+      if (reads.some((alias2) => held2.has(alias2))) {
+        held2.add(field2.alias);
         grew = true;
       }
     }
   }
-  return held;
+  return held2;
 }
 function printed(model, template) {
   const content = model.templates?.find((one) => one.alias === template)?.content;
@@ -55515,13 +55526,13 @@ function printed(model, template) {
 }
 function actsReadBlocks(model, entity, section, acts) {
   if (section.blocks.length === 0) return false;
-  const held = blockHeld(model, entity, section.blocks);
+  const held2 = blockHeld(model, entity, section.blocks);
   return section.acts.some((alias2) => {
     const act = acts.find((one) => one.alias === alias2);
     if (act === void 0) return false;
     const asked = act.asks.flatMap((ask) => typeof ask === "string" ? [ask] : []);
     const reads = [...act.requires, ...act.recommends, ...asked, ...printed(model, act.template)];
-    return reads.some((field2) => held.has(field2)) || !reads.some((field2) => section.fields.includes(field2));
+    return reads.some((field2) => held2.has(field2)) || !reads.some((field2) => section.fields.includes(field2));
   });
 }
 function resolveAct(model, app, act, checks) {
@@ -55539,7 +55550,7 @@ function resolveAct(model, app, act, checks) {
   );
   const feeds = (name) => Object.entries(set2).filter(([, value]) => value.kind === "input" && value.name === name).map(([field2]) => field2);
   const sharedBy = (field2) => (app.acts ?? []).some(
-    (other) => other !== act && ((other.asks ?? []).includes(field2) || Object.entries(other.set ?? {}).some(([written2, value]) => written2 === field2 && typeof value === "string" && value.startsWith(SET_INPUT)))
+    (other2) => other2 !== act && ((other2.asks ?? []).includes(field2) || Object.entries(other2.set ?? {}).some(([written2, value]) => written2 === field2 && typeof value === "string" && value.startsWith(SET_INPUT)))
   );
   const asField = new Map(
     act.workflow !== void 0 || act.template !== void 0 ? [] : inputs.flatMap((input) => {
@@ -55937,8 +55948,8 @@ function checkApp(model, app, at2) {
 }
 function hiddenWhenOffered(shown, offered) {
   return Object.entries(shown ?? {}).some(([field2, options]) => {
-    const held = offered?.[field2];
-    return held !== void 0 && !held.some((option) => options.includes(option));
+    const held2 = offered?.[field2];
+    return held2 !== void 0 && !held2.some((option) => options.includes(option));
   });
 }
 function misplacedMove(act, title, entry) {
@@ -56020,11 +56031,11 @@ function checkStagedAct(display, section, act, path39) {
   }
   const field2 = status.field;
   if (field2 === void 0) return [];
-  const held = act.when?.[field2];
-  if (held === void 0) {
+  const held2 = act.when?.[field2];
+  if (held2 === void 0) {
     return [error51(path39, `"${act.alias}" is offered whatever "${field2}" holds, and "${section.title}" is the work only while it is ${at2.join(" or ")} \u2014 narrow its \`when\` to that, or ${elsewhere}`)];
   }
-  const outside = held.filter((option) => !at2.includes(option));
+  const outside = held2.filter((option) => !at2.includes(option));
   return outside.length === 0 ? [] : [error51(path39, `"${act.alias}" is offered while "${field2}" is ${outside.join(" or ")}, when "${section.title}" is not the work \u2014 ${elsewhere}`)];
 }
 function blockIdentity(block2) {
@@ -56048,8 +56059,8 @@ function checkWhere(child, block2, at2) {
     if (field2.required !== true) {
       return [error51(path39, `"${name}" is optional on "${child.alias}" \u2014 a row holding none would stand in no block while every unnarrowed total counts it; make it required`)];
     }
-    const held = new Set((field2.options ?? []).map((option) => option.alias));
-    const stray = options.filter((option) => !held.has(option));
+    const held2 = new Set((field2.options ?? []).map((option) => option.alias));
+    const stray = options.filter((option) => !held2.has(option));
     return [
       ...stray.length === 0 ? [] : [error51(path39, `names ${stray.map((one) => `"${one}"`).join(", ")}, which "${name}" has no option of`)],
       ...options.length === 1 && (block2.columns ?? []).includes(name) ? [error51(path39, `holds every row at "${options[0] ?? ""}", so its column says one thing on every row \u2014 drop the column`)] : []
@@ -56866,9 +56877,9 @@ var HISTORY_WORDS = {
   }
 };
 function derivedLabelClash(entity, stage, table, backLink, derivesBackLink, tables) {
-  const other = tables.get(table.label);
-  if (other !== void 0) {
-    return `derives a table labelled "${table.label}" from the status "${stage.label}", and "${other}" is already labelled so \u2014 rename the status field, which the table is named after`;
+  const other2 = tables.get(table.label);
+  if (other2 !== void 0) {
+    return `derives a table labelled "${table.label}" from the status "${stage.label}", and "${other2}" is already labelled so \u2014 rename the status field, which the table is named after`;
   }
   if (derivesBackLink && entity.fields.some((field2) => field2.label === backLink.label)) {
     return `derives a "${backLink.label}" link on "${entity.alias}", which already has a field labelled so \u2014 rename that field, or the status "${stage.label}" the link is named after`;
@@ -57321,7 +57332,7 @@ function resultSideEffects(result) {
 
 // src/version.ts
 init_define_LOTICS_KIT_VERSIONS();
-var VERSION = "0.251.0";
+var VERSION = "0.252.0";
 
 // src/timezone.ts
 init_define_LOTICS_KIT_VERSIONS();
@@ -59180,7 +59191,8 @@ function describeApp(model, app) {
   });
   lines.push(...block("checks", checks));
   const menu = app.acts.filter((act) => act.on === "record" && act.of === void 0 && !app.record.sections.some((section) => [...section.entry, ...section.acts].includes(act.alias)));
-  lines.push(`    header \u22EF ${[...menu.map((act) => act.label), "Delete"].join(", ")}`);
+  const removes = appWritePlan(model, app).get(app.entity)?.remove === true;
+  lines.push(`    header \u22EF ${[...menu.map((act) => act.label), ...removes ? ["Delete"] : []].join(", ") || "\u2014"}`);
   if (stages !== void 0) {
     lines.push(
       ...block(
@@ -59819,14 +59831,14 @@ function uniqueDifferences(entity, here, fields) {
     return found?.how === "id" || found?.how === "label" ? found.live.alias : void 0;
   };
   const named = (among, tuple2) => tuple2.map((alias2) => among.fields.find((field2) => field2.alias === alias2)?.label ?? alias2).join(" + ");
-  const held = new Set((here.unique ?? []).map(signature));
+  const held2 = new Set((here.unique ?? []).map(signature));
   const stated2 = /* @__PURE__ */ new Set();
   const lines = [];
   for (const tuple2 of entity.unique ?? []) {
     const live = tuple2.flatMap((alias2) => liveAlias(alias2) ?? []);
     const whole = live.length === tuple2.length ? signature(live) : void 0;
     if (whole !== void 0) stated2.add(whole);
-    if (whole !== void 0 && held.has(whole)) continue;
+    if (whole !== void 0 && held2.has(whole)) continue;
     lines.push({ side: "create", line: `  ${entity.label}: workspace lacks the unique set ${named(entity, tuple2)}` });
   }
   for (const tuple2 of here.unique ?? []) {
@@ -60109,10 +60121,9 @@ function aggregateRows(rows, aggregate) {
 
 // ../shared/src/schemas/app_spec.ts
 var APP_SPEC_VERSION = 3;
-var liveId = (prefix, what) => zod_default.string().regex(new RegExp(`^${prefix}_.+`), `${what} must be a live \`${prefix}_\` id, not a model alias`);
-var specTableIdSchema = liveId("tbl", "a table");
-var specFieldIdSchema = liveId("fld", "a field");
-var specOptionIdSchema = liveId("opt", "an option");
+var specTableIdSchema = zod_default.string().refine(isTableId, "a table must be a live table id (`tbl_\u2026`, or an older table's UUID), not a model alias");
+var specFieldIdSchema = zod_default.string().refine(isStoredKey, "a field must be a live field key, not a label");
+var specOptionIdSchema = zod_default.string().refine((id) => id.startsWith("opt_") && isStoredKey(id), "an option must be a live `opt_` key, not a model alias");
 var specColumnAliasSchema = zod_default.string().min(1);
 var specReadSchema = zod_default.object({
   query: zod_default.string().min(1),
@@ -63945,16 +63956,16 @@ function kitCheckouts(given) {
   const name = fs13.existsSync(own) ? manifestSchema.parse(JSON.parse(fs13.readFileSync(own, "utf-8"))).name : void 0;
   if (name !== void 0 && CHECKOUT_PACKAGES.includes(name)) return [given];
   const root = path14.join(given, "packages");
-  const held = fs13.existsSync(root) ? fs13.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path14.join(root, entry.name)).filter((dir) => {
+  const held2 = fs13.existsSync(root) ? fs13.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path14.join(root, entry.name)).filter((dir) => {
     const manifest = path14.join(dir, "package.json");
     if (!fs13.existsSync(manifest)) return false;
     const named = manifestSchema.parse(JSON.parse(fs13.readFileSync(manifest, "utf-8"))).name;
     return named !== void 0 && CHECKOUT_PACKAGES.includes(named);
   }) : [];
-  if (held.length === 0) {
+  if (held2.length === 0) {
     fail(`${given} is neither ${CHECKOUT_PACKAGES.join(" nor ")} nor a checkout holding them under packages/ \u2014 name one of those.`);
   }
-  return held;
+  return held2;
 }
 function npmOutput(args, cwd) {
   return new Promise((resolve4, reject) => {
@@ -63979,19 +63990,19 @@ function proveKitInstall(projectDir, packed) {
 }
 async function packDependencies(kits, kitDir) {
   const packed = [];
-  const held = new Set(kits.map((kit) => kit.name));
+  const held2 = new Set(kits.map((kit) => kit.name));
   const queue = [...kits];
   for (let kit = queue.shift(); kit !== void 0; kit = queue.shift()) {
     const manifest = manifestSchema.parse(JSON.parse(fs13.readFileSync(path14.join(kit.source, "package.json"), "utf-8")));
     const wanted2 = Object.entries({ ...manifest.dependencies, ...manifest.peerDependencies }).filter(([name]) => name.startsWith("@lotics/"));
     for (const [name, range2] of wanted2) {
-      if (held.has(name)) continue;
+      if (held2.has(name)) continue;
       const floor2 = range2.replace(/^[\^~]/, "");
       const latest = await fetchLatestNpmVersion(name);
       if (latest !== null && compareReleases(latest, floor2) >= 0) continue;
       const sibling = siblingPackage(kit.source, name);
       if (sibling === void 0) continue;
-      held.add(name);
+      held2.add(name);
       const one = await packCheckout(sibling, kitDir, null);
       packed.push(one);
       queue.push(one);
@@ -64012,9 +64023,9 @@ function caretRange(range2) {
   const floor2 = [Number(match2[1]), Number(match2[2]), Number(match2[3])];
   return { line: releaseLine(range2.slice(1)), floor: floor2 };
 }
-function accepts(held, wanted2) {
-  if (held === wanted2) return true;
-  const have = caretRange(held);
+function accepts(held2, wanted2) {
+  if (held2 === wanted2) return true;
+  const have = caretRange(held2);
   const want = caretRange(wanted2);
   if (have === null || want === null || have.line !== want.line) return false;
   const differs = have.floor.findIndex((part, at2) => part !== want.floor[at2]);
@@ -74004,13 +74015,13 @@ function entitiesToBind(model, set2) {
       const link = rule.default_from?.split(".")[0];
       if (link !== void 0) add(linkTarget(entity, model.entities, link)?.alias);
     }
-    for (const [other, rules] of Object.entries(model.write_rules ?? {})) {
-      const from = model.entities.find((one) => one.alias === other);
+    for (const [other2, rules] of Object.entries(model.write_rules ?? {})) {
+      const from = model.entities.find((one) => one.alias === other2);
       if (from === void 0) continue;
       for (const [alias2, rule] of Object.entries(rules.fields ?? {})) {
         const bounds = [rule.min, rule.max].flatMap((bound) => typeof bound === "string" && bound.includes(".") ? [bound.split(".")[0]] : []);
         const links = [...bounds, ...rule.same === void 0 ? [] : [alias2]];
-        if (links.some((link) => linkTarget(from, model.entities, link)?.alias === entity.alias)) add(other);
+        if (links.some((link) => linkTarget(from, model.entities, link)?.alias === entity.alias)) add(other2);
       }
     }
   }
@@ -74040,7 +74051,7 @@ function bindModel(model, wanted2, live) {
   const columns = /* @__PURE__ */ new Map();
   for (const [alias2, { entity, table }] of found) {
     const index = liveIndex(table.fields, { id: (field2) => field2.id, label: (field2) => field2.name });
-    const held = /* @__PURE__ */ new Map();
+    const held2 = /* @__PURE__ */ new Map();
     for (const field2 of entity.fields) {
       const key = fieldKeyName(alias2, field2.alias);
       const column = bindAlias(live.binding?.entities[alias2]?.fields[field2.alias]?.id, field2.label, index);
@@ -74060,33 +74071,33 @@ function bindModel(model, wanted2, live) {
         problems.set(key, `field "${field2.label}" holds ${multi ? "several values" : "one value"} in this workspace and ${multi ? "one" : "several"} in the model`);
         continue;
       }
-      held.set(field2.alias, { field: field2, live: column.live });
+      held2.set(field2.alias, { field: field2, live: column.live });
     }
-    columns.set(alias2, held);
+    columns.set(alias2, held2);
   }
   const optionsOf2 = (entityAlias, fieldAlias2, hops = 0) => {
-    const held = columns.get(entityAlias)?.get(fieldAlias2);
+    const held2 = columns.get(entityAlias)?.get(fieldAlias2);
     const entity = found.get(entityAlias)?.entity;
-    if (held === void 0 || entity === void 0 || hops > 8) return void 0;
-    if (held.field.type === "lookup") {
-      const target = linkTarget(entity, model.entities, held.field.source_field_alias);
-      return target === void 0 ? void 0 : optionsOf2(target.alias, held.field.lookup_field_alias, hops + 1);
+    if (held2 === void 0 || entity === void 0 || hops > 8) return void 0;
+    if (held2.field.type === "lookup") {
+      const target = linkTarget(entity, model.entities, held2.field.source_field_alias);
+      return target === void 0 ? void 0 : optionsOf2(target.alias, held2.field.lookup_field_alias, hops + 1);
     }
-    if (held.field.type !== "select") return void 0;
-    const index = liveIndex(held.live.options ?? [], { id: (option) => option.id, label: (option) => option.label });
+    if (held2.field.type !== "select") return void 0;
+    const index = liveIndex(held2.live.options ?? [], { id: (option) => option.id, label: (option) => option.label });
     const recorded = live.binding?.entities[entityAlias]?.fields[fieldAlias2]?.options;
     const options = /* @__PURE__ */ new Map();
-    for (const option of held.field.options) {
+    for (const option of held2.field.options) {
       const bound = bindAlias(recorded?.[option.alias]?.id, option.label, index);
       if (bound.how === "id" || bound.how === "label") options.set(option.alias, bound.live.id);
-      else problems.set(`${fieldKeyName(entityAlias, fieldAlias2)}:${option.alias}`, `option "${option.label}" of "${held.field.label}" is not in this workspace`);
+      else problems.set(`${fieldKeyName(entityAlias, fieldAlias2)}:${option.alias}`, `option "${option.label}" of "${held2.field.label}" is not in this workspace`);
     }
     return options;
   };
   const boundFields = /* @__PURE__ */ new Map();
-  for (const [alias2, held] of columns) {
+  for (const [alias2, held2] of columns) {
     const fields = /* @__PURE__ */ new Map();
-    for (const [fieldAlias2, { field: field2, live: column }] of held) {
+    for (const [fieldAlias2, { field: field2, live: column }] of held2) {
       const options = optionsOf2(alias2, fieldAlias2);
       fields.set(fieldAlias2, { alias: fieldAlias2, id: column.id, field: field2, ...options === void 0 ? {} : { options } });
     }
@@ -74258,6 +74269,21 @@ function heldEmpty(field2, value) {
 function callerValue(field2) {
   return field2.field.type === "select_member" && field2.field.multi === true ? `isNull(${CALLER}) ? null : [${CALLER}]` : CALLER;
 }
+function sends(s, field2) {
+  if (!s.carries.has(field2.alias)) return void 0;
+  return s.row === void 0 ? `!isNull(${s.from}.${field2.alias})` : `includes(keys(${s.from}), ${str(field2.alias)})`;
+}
+function leftBy(s, field2) {
+  const held2 = s.row === void 0 ? "null" : `${s.row}.data[${str(field2.id)}]`;
+  if (!s.carries.has(field2.alias)) return held2;
+  return s.row === void 0 ? `${s.from}.${field2.alias}` : `(${sends(s, field2)} ? ${s.from}.${field2.alias} : ${held2})`;
+}
+function landsOn(s, field2) {
+  return s.inputs.has(field2.alias) ? field2.alias : field2.id;
+}
+function other(rows, record2) {
+  return record2 === void 0 ? `first(${rows})` : `first(filter(${rows}, (one) => one.id != ${record2}))`;
+}
 function scopeCell(clause, local) {
   const row = (clause.through ?? []).reduce((at2, hop) => `linked(${at2}[${str(hop.id)}])[0]`, `${local}.data`);
   return clause.through === void 0 ? `${row}[${str(clause.field.id)}]` : `${row}?.[${str(clause.field.id)}]`;
@@ -74273,6 +74299,13 @@ function scopePasses(rule, local) {
 function scopeReadsRow(rule) {
   return rule !== void 0 && rule.clauses.some((clause) => clause.kind !== "member_of");
 }
+function held(condition, at2) {
+  const values2 = Array.isArray(condition.value) ? condition.value : [condition.value];
+  if (condition.field.field.type === "select" && condition.field.field.multi === true) {
+    return `(${values2.map((value) => `includes(${at2}, ${JSON.stringify(value)})`).join(" || ")})`;
+  }
+  return `includes(${JSON.stringify(values2)}, ${at2})`;
+}
 function whereCheck(local, condition) {
   const at2 = `${local}.data[${str(condition.field.id)}]`;
   const value = JSON.stringify(condition.value);
@@ -74290,9 +74323,9 @@ function whereCheck(local, condition) {
     case "less_than_or_equal_to":
       return `${at2} <= ${value}`;
     case "has_any_of":
-      return `includes(${value}, ${at2})`;
+      return held(condition, at2);
     case "has_none_of":
-      return `!includes(${value}, ${at2})`;
+      return `!${held(condition, at2)}`;
     default:
       return "false";
   }
@@ -74320,7 +74353,8 @@ function checksOn(checks, cellOf) {
   return validateBlock(
     checks.map((check2) => {
       const cell = cellOf(str(check2.field.id));
-      return check2.text ? checkLine(`!isEmpty(trim(coalesce(${cell}, "")))`, void 0, cell) : checkLine(`${cell} == true`, void 0, str(check2.label));
+      const text = `trim(coalesce(${cell}, ""))`;
+      return check2.text ? checkLine(`!isEmpty(${text})`, void 0, text) : checkLine(`${cell} == true`, void 0, str(check2.label));
     })
   );
 }
@@ -74336,60 +74370,73 @@ function locksGuard(locks, local, words) {
     ];
   });
 }
-function valueChecks(fields, words, sent, from = "i") {
+function valueChecks(fields, words, s) {
   return fields.flatMap((one) => {
     const name = one.field.alias;
-    const given = sent === void 0 ? `!isNull(${from}.${name})` : `${sent(name)} && !isNull(${from}.${name})`;
+    const sent = sends(s, one.field);
+    if (sent === void 0) return [];
+    const value = `${s.from}.${name}`;
+    const given = s.row === void 0 ? sent : `${sent} && !isNull(${value})`;
+    const at2 = landsOn(s, one.field);
     return [
-      ...one.min?.kind !== "value" ? [] : [checkLine(`${given} && ${from}.${name} < ${one.min.value}`, name, str(words.refusals.below(one.label, String(one.min.value))))],
-      ...one.max?.kind !== "value" ? [] : [checkLine(`${given} && ${from}.${name} > ${one.max.value}`, name, str(words.refusals.above(one.label, String(one.max.value))))]
+      ...one.min?.kind !== "value" ? [] : [checkLine(`${given} && ${value} < ${one.min.value}`, at2, str(words.refusals.below(one.label, String(one.min.value))))],
+      ...one.max?.kind !== "value" ? [] : [checkLine(`${given} && ${value} > ${one.max.value}`, at2, str(words.refusals.above(one.label, String(one.max.value))))]
     ];
   });
 }
 function boundsByField(fields) {
   return fields.some((one) => [one.min, one.max].some((bound) => bound !== void 0 && bound.kind !== "value"));
 }
-function fieldBoundChecks(fields, words, row, from = "i") {
-  const sent = (name) => row === void 0 ? `!isNull(${from}.${name})` : `includes(keys(${from}), ${str(name)})`;
-  const now = (field2) => row === void 0 ? `${from}.${field2.alias}` : `(${sent(field2.alias)} ? ${from}.${field2.alias} : ${row}.data[${str(field2.id)}])`;
-  const fetched = /* @__PURE__ */ new Set();
+function fieldBoundChecks(fields, words, s) {
   const lines = [];
+  const bound = /* @__PURE__ */ new Set();
+  const local = (name, value) => {
+    if (!bound.has(name)) {
+      bound.add(name);
+      lines.push(`const ${name} = ${value};`);
+    }
+    return name;
+  };
+  const leftOf = (field2) => local(`${camel(field2.alias)}Left`, leftBy(s, field2));
   const checks = [];
   for (const one of fields) {
-    for (const [side, bound] of [["min", one.min], ["max", one.max]]) {
-      if (bound === void 0 || bound.kind === "value") continue;
-      const value = now(one.field);
+    for (const [side, limitBy] of [["min", one.min], ["max", one.max]]) {
+      if (limitBy === void 0 || limitBy.kind === "value") continue;
+      if (limitBy.kind === "field" && s.row === void 0 && !s.carries.has(limitBy.field.alias)) continue;
+      const moved = [sends(s, one.field), sends(s, limitBy.kind === "field" ? limitBy.field : limitBy.link)].filter((sent) => sent !== void 0);
+      if (moved.length === 0) continue;
       let limit;
-      let moved;
-      if (bound.kind === "field") {
-        if (row === void 0 && !fields.some((other) => other.field.id === bound.field.id)) continue;
-        limit = now(bound.field);
-        moved = `(${sent(one.field.alias)} || ${sent(bound.field.alias)})`;
+      if (limitBy.kind === "field") {
+        limit = leftOf(limitBy.field);
       } else {
-        const local = `${camel(bound.link.alias)}Bound`;
-        if (!fetched.has(local)) {
-          fetched.add(local);
+        const linked = `${camel(limitBy.link.alias)}Bound`;
+        if (!bound.has(linked)) {
+          bound.add(linked);
+          const sent = sends(s, limitBy.link);
           lines.push(
-            `let ${local} = ${row === void 0 ? "null" : `linked(${row}.data[${str(bound.link.id)}])[0]`};`,
-            `if (${sent(bound.link.alias)} && !isNull(${from}.${bound.link.alias})) {`,
-            `  const ${local}Row = await get_record({ table_id: ${str(bound.table)}, record_id: ${from}.${bound.link.alias} });`,
-            `  ${local} = ${local}Row.data;`,
-            `}`
+            `let ${linked} = ${s.row === void 0 ? "null" : `linked(${s.row}.data[${str(limitBy.link.id)}])[0]`};`,
+            ...sent === void 0 ? [] : [
+              `if (${sent} && !isNull(${s.from}.${limitBy.link.alias})) {`,
+              `  const ${linked}Row = await get_record({ table_id: ${str(limitBy.table)}, record_id: ${s.from}.${limitBy.link.alias} });`,
+              `  ${linked} = ${linked}Row.data;`,
+              `}`
+            ]
           );
         }
-        limit = `(isNull(${local}) ? null : ${local}[${str(bound.field.id)}])`;
-        moved = `(${sent(one.field.alias)} || ${sent(bound.link.alias)})`;
+        limit = local(`${camel(`${limitBy.link.alias}_${limitBy.field.alias}`)}Limit`, `isNull(${linked}) ? null : ${linked}[${str(limitBy.field.id)}]`);
       }
+      const value = leftOf(one.field);
       const dated = one.field.field.type === "date";
       const fails = side === "min" ? dated ? `isBefore(${value}, ${limit})` : `${value} < ${limit}` : dated ? `isAfter(${value}, ${limit})` : `${value} > ${limit}`;
-      const said = side === "min" ? words.refusals.below(one.label, bound.label) : words.refusals.above(one.label, bound.label);
-      checks.push(checkLine(`${moved} && !isNull(${value}) && !isNull(${limit}) && ${fails}`, one.field.alias, str(said)));
+      const said = side === "min" ? words.refusals.below(one.label, limitBy.label) : words.refusals.above(one.label, limitBy.label);
+      checks.push(checkLine(`${moved.length === 1 ? moved[0] : `(${moved.join(" || ")})`} && !isNull(${value}) && !isNull(${limit}) && ${fails}`, landsOn(s, one.field), str(said)));
     }
   }
   return [...lines, ...validateBlock(checks)];
 }
-function heldGuards(held, record2, words, from = "i") {
-  return held.flatMap((one, at2) => {
+function heldGuards(held2, record2, words, s) {
+  const from = s.from;
+  return held2.flatMap((one, at2) => {
     const local = `outside${at2 + 1}`;
     const dated = one.child.bounded.field.type === "date";
     const operator = one.side === "min" ? dated ? "before" : "less_than" : dated ? "after" : "greater_than";
@@ -74404,18 +74451,19 @@ function heldGuards(held, record2, words, from = "i") {
       `  });`,
       `  ${local} = first(${local}Rows.records);`,
       `}`,
-      ...validateBlock([checkLine(`!isNull(${local})`, one.field.alias, str(words.refusals.strands(one.child.label, one.field.field.label)))])
+      ...validateBlock([checkLine(`!isNull(${local})`, landsOn(s, one.field), str(words.refusals.strands(one.child.label, one.field.field.label)))])
     ];
   });
 }
-function overlapGuard(overlap, table, words, at2, asked, from = "i") {
-  if (at2 === void 0 && ![overlap.from, overlap.to, ...overlap.by].every((field2) => asked?.has(field2.alias) === true)) return [];
-  const sent = (field2) => at2 === void 0 ? `!isNull(${from}.${field2.alias})` : `includes(keys(${from}), ${str(field2.alias)})`;
-  const now = (field2) => at2 === void 0 ? `${from}.${field2.alias}` : `(${sent(field2)} ? ${from}.${field2.alias} : ${at2.row}.data[${str(field2.id)}])`;
+function overlapGuard(overlap, table, words, s, record2) {
+  if (s.row === void 0 && ![overlap.from, overlap.to, ...overlap.by].every((field2) => s.carries.has(field2.alias))) return [];
+  const now = (field2) => leftBy(s, field2);
   const shared = (field2) => {
     const type = field2.field.type;
     if (type === "select_record_link") {
-      const ids = at2 === void 0 ? `[${from}.${field2.alias}]` : `(${sent(field2)} ? [${from}.${field2.alias}] : ${at2.row}.data[${str(field2.id)}])`;
+      const sent2 = sends(s, field2);
+      const own = `[${s.from}.${field2.alias}]`;
+      const ids = sent2 === void 0 ? `${s.row}.data[${str(field2.id)}]` : s.row === void 0 ? own : `(${sent2} ? ${own} : ${s.row}.data[${str(field2.id)}])`;
       return `{ node_type: "condition", field_key: ${str(field2.id)}, operator: "has_any_of", value: ${ids} }`;
     }
     if (type === "select_member" || type === "select") {
@@ -74428,52 +74476,61 @@ function overlapGuard(overlap, table, words, at2, asked, from = "i") {
     ...overlap.by.map(shared),
     `{ node_type: "condition", field_key: ${str(overlap.from.id)}, operator: "on_or_before", value: ${day(overlap.to)} }`,
     `{ node_type: "condition", field_key: ${str(overlap.to.id)}, operator: "on_or_after", value: ${day(overlap.from)} }`,
-    ...overlap.holds.map((hold) => `{ node_type: "condition", field_key: ${str(hold.field.id)}, operator: "has_any_of", value: [${hold.options.map(str).join(", ")}] }`),
-    ...at2 === void 0 ? [] : [`{ node_type: "condition", type: "record_id", operator: "is_none_of", value: [${at2.record}] }`]
+    ...overlap.holds.map((hold) => `{ node_type: "condition", field_key: ${str(hold.field.id)}, operator: "has_any_of", value: [${hold.options.map(str).join(", ")}] }`)
   ];
-  const counted = overlap.holds.filter((hold) => at2 !== void 0 || asked?.has(hold.field.alias) === true);
+  const counted = overlap.holds.filter((hold) => s.row !== void 0 || s.carries.has(hold.field.alias));
   const holds = [`!isNull(${now(overlap.from)})`, `!isNull(${now(overlap.to)})`, ...counted.map((hold) => `includes([${hold.options.map(str).join(", ")}], ${now(hold.field)})`)];
-  const moved = at2 === void 0 ? [] : [`(${[overlap.from, overlap.to, ...overlap.by, ...overlap.holds.map((hold) => hold.field)].map(sent).join(" || ")})`];
+  const sent = [overlap.from, overlap.to, ...overlap.by, ...overlap.holds.map((hold) => hold.field)].flatMap((field2) => sends(s, field2) ?? []);
+  if (s.row !== void 0 && sent.length === 0) return [];
+  const moved = s.row === void 0 ? [] : [`(${sent.join(" || ")})`];
   const when = [...moved, ...holds].join(" && ");
   return [
     `let covered = null;`,
     `if (${when}) {`,
     `  const covering = await query_records({`,
     `    table_id: ${str(table.id)},`,
+    // The row itself, and one other if any holds the span.
+    `    limit: ${record2 === void 0 ? 1 : 2},`,
     `    filters: { node_type: "group", logic: "and", children: [${conditions.join(", ")}] },`,
     `  });`,
-    `  covered = first(covering.records);`,
+    `  covered = ${other("covering.records", record2)};`,
     `}`,
-    ...validateBlock([checkLine(`!isNull(covered)`, overlap.from.alias, str(words.refusals.overlaps(overlap.label)))])
+    ...validateBlock([checkLine(`!isNull(covered)`, landsOn(s, overlap.from), str(words.refusals.overlaps(overlap.label)))])
   ];
 }
-function expectGuard(expect, table, words, at2, asked) {
+function expectGuard(expect, table, words, s, record2) {
   const { via, key } = expect;
-  if (at2 === void 0 && !(asked?.has(via.alias) === true && asked.has(key.alias))) return [];
-  const sent = (field2) => at2 === void 0 ? `!isNull(i.${field2.alias})` : `includes(keys(i), ${str(field2.alias)})`;
-  const held = (field2) => field2.field.type === "select_record_link" ? at2 === void 0 ? `[i.${field2.alias}]` : `(${sent(field2)} ? [i.${field2.alias}] : ${at2.row}.data[${str(field2.id)}])` : at2 === void 0 ? `[i.${field2.alias}]` : `[(${sent(field2)} ? i.${field2.alias} : ${at2.row}.data[${str(field2.id)}])]`;
-  const holds = (field2) => at2 === void 0 ? `!isNull(i.${field2.alias})` : field2.field.type === "select_record_link" ? `!isEmpty(${held(field2)})` : `!isNull(first(${held(field2)}))`;
+  if (s.row === void 0 && !(s.carries.has(via.alias) && s.carries.has(key.alias))) return [];
+  const held2 = (field2) => {
+    const sent2 = sends(s, field2);
+    const own = `[${s.from}.${field2.alias}]`;
+    const stored = field2.field.type === "select_record_link" ? `${s.row}.data[${str(field2.id)}]` : `[${s.row}.data[${str(field2.id)}]]`;
+    return sent2 === void 0 ? stored : s.row === void 0 ? own : `(${sent2} ? ${own} : ${stored})`;
+  };
+  const holds = (field2) => s.row === void 0 ? `!isNull(${s.from}.${field2.alias})` : field2.field.type === "select_record_link" ? `!isEmpty(${held2(field2)})` : `!isNull(first(${held2(field2)}))`;
   const local = `${camel(key.alias)}Held`;
   const among = expect.among.map(
-    (field2) => `(isNull(first(${held(field2)})) ? { node_type: "condition", field_key: ${str(field2.id)}, operator: "is_empty" } : { node_type: "condition", field_key: ${str(field2.id)}, operator: "has_any_of", value: ${held(field2)} })`
+    (field2) => `(isNull(first(${held2(field2)})) ? { node_type: "condition", field_key: ${str(field2.id)}, operator: "is_empty" } : { node_type: "condition", field_key: ${str(field2.id)}, operator: "has_any_of", value: ${held2(field2)} })`
   );
   const conditions = [
-    `{ node_type: "condition", field_key: ${str(via.id)}, operator: "has_any_of", value: ${held(via)} }`,
-    `{ node_type: "condition", field_key: ${str(key.id)}, operator: "has_any_of", value: ${held(key)} }`,
-    ...among,
-    ...at2 === void 0 ? [] : [`{ node_type: "condition", type: "record_id", operator: "is_none_of", value: [${at2.record}] }`]
+    `{ node_type: "condition", field_key: ${str(via.id)}, operator: "has_any_of", value: ${held2(via)} }`,
+    `{ node_type: "condition", field_key: ${str(key.id)}, operator: "has_any_of", value: ${held2(key)} }`,
+    ...among
   ];
-  const when = [...at2 === void 0 ? [] : [`(${[via, key, ...expect.among].map(sent).join(" || ")})`], holds(via), holds(key)].join(" && ");
+  const sent = [via, key, ...expect.among].flatMap((field2) => sends(s, field2) ?? []);
+  if (s.row !== void 0 && sent.length === 0) return [];
+  const when = [...s.row === void 0 ? [] : [`(${sent.join(" || ")})`], holds(via), holds(key)].join(" && ");
   return [
     `let ${local} = null;`,
     `if (${when}) {`,
     `  const holding = await query_records({`,
     `    table_id: ${str(table.id)},`,
+    `    limit: ${record2 === void 0 ? 1 : 2},`,
     `    filters: { node_type: "group", logic: "and", children: [${conditions.join(", ")}] },`,
     `  });`,
-    `  ${local} = first(holding.records);`,
+    `  ${local} = ${other("holding.records", record2)};`,
     `}`,
-    ...validateBlock([checkLine(`!isNull(${local})`, key.alias, str(words.refusals.expected(expect.label, expect.record)))])
+    ...validateBlock([checkLine(`!isNull(${local})`, landsOn(s, key), str(words.refusals.expected(expect.label, expect.record)))])
   ];
 }
 function admitsReadsRow(link) {
@@ -74491,7 +74548,8 @@ function linkChecks(fields, words, own) {
     return editedByDelta(one.field.field) ? [`for (const picked of i.${name} ?? []) {`, ...indent([...fetch2("picked"), ...refusal]), `}`] : [`if (!isNull(i.${name})) {`, ...indent([...fetch2(`i.${name}`), ...refusal]), `}`];
   });
 }
-function keptGuards(kept, written, words, from) {
+function keptGuards(kept, written, words, s) {
+  const from = s.from;
   const sent = (name) => `includes(keys(${from}), ${str(name)})`;
   const writes = new Set(written.map((one) => one.field.alias));
   const own = (field2) => writes.has(field2.alias) ? `(${sent(field2.alias)} ? ${from}.${field2.alias} : first(row.data[${str(field2.id)}]))` : `first(row.data[${str(field2.id)}])`;
@@ -74503,7 +74561,7 @@ function keptGuards(kept, written, words, from) {
     const passes = link.same.map((pair) => `includes(coalesce(${local}.data[${str(pair.theirs.id)}], []), ${own(pair.own)})`).join(" && ");
     const check2 = (id) => [
       `const ${local} = await get_record({ table_id: ${str(link.target.id)}, record_id: ${id} });`,
-      ...validateBlock([checkLine(`!(${passes})`, moved[0].own.alias, str(words.refusals.mismatched(link.target.label, moved[0].own.field.label)))])
+      ...validateBlock([checkLine(`!(${passes})`, landsOn(s, moved[0].own), str(words.refusals.mismatched(link.target.label, moved[0].own.field.label)))])
     ];
     const when = moved.map((pair) => sent(pair.own.alias)).join(" || ");
     if (editedByDelta(one.field.field)) {
@@ -74511,17 +74569,18 @@ function keptGuards(kept, written, words, from) {
       const keeps2 = writes.has(one.field.alias) ? [`if (!includes(coalesce(i.${removed}, []), kept)) {`, ...indent(check2("kept")), `}`] : check2("kept");
       return [`if (${when}) {`, `  for (const kept of coalesce(row.data[${str(one.field.id)}], [])) {`, ...indent(keeps2, "    "), `  }`, `}`];
     }
-    const held = `${camel(one.field.alias)}Kept`;
+    const held2 = `${camel(one.field.alias)}Kept`;
     const keeps = writes.has(one.field.alias) ? `(${when}) && !${sent(one.field.alias)}` : when;
-    return [`if (${keeps}) {`, `  const ${held} = first(row.data[${str(one.field.id)}]);`, `  if (!isNull(${held})) {`, ...indent(check2(held), "    "), `  }`, `}`];
+    return [`if (${keeps}) {`, `  const ${held2} = first(row.data[${str(one.field.id)}]);`, `  if (!isNull(${held2})) {`, ...indent(check2(held2), "    "), `  }`, `}`];
   });
 }
-function strayGuards(strays, record2, words, from) {
+function strayGuards(strays, record2, words, s) {
+  const from = s.from;
   return strays.flatMap((one, at2) => {
     const local = `stray${at2 + 1}`;
     const sent = `includes(keys(${from}), ${str(one.field.alias)})`;
     const pointing = `{ node_type: "condition", field_key: ${str(one.child.link.id)}, operator: "has_any_of", value: [${record2}] }`;
-    const other = `{ node_type: "condition", field_key: ${str(one.child.compared.id)}, operator: "has_none_of", value: [${from}.${one.field.alias}] }`;
+    const other2 = `{ node_type: "condition", field_key: ${str(one.child.compared.id)}, operator: "has_none_of", value: [${from}.${one.field.alias}] }`;
     const read2 = (when, children) => [
       `if (${when}) {`,
       `  const ${local}Rows = await query_records({`,
@@ -74534,10 +74593,10 @@ function strayGuards(strays, record2, words, from) {
     ];
     return [
       `let ${local} = null;`,
-      ...read2(`${sent} && !isNull(${from}.${one.field.alias})`, [pointing, other]),
+      ...read2(`${sent} && !isNull(${from}.${one.field.alias})`, [pointing, other2]),
       // A required field is never emptied, so only an optional one asks for any row at all.
       ...one.field.field.required === true ? [] : read2(`${sent} && isNull(${from}.${one.field.alias})`, [pointing]),
-      ...validateBlock([checkLine(`!isNull(${local})`, one.field.alias, str(words.refusals.mismatched(one.child.label, one.field.field.label)))])
+      ...validateBlock([checkLine(`!isNull(${local})`, landsOn(s, one.field), str(words.refusals.mismatched(one.child.label, one.field.field.label)))])
     ];
   });
 }
@@ -74560,7 +74619,7 @@ function appendHistory(history, record2, moved, copies = []) {
     `});`
   ];
 }
-function milestoneOrder(stages, touches, left, words) {
+function milestoneOrder(stages, touches, left, words, landing) {
   const applies = (stage) => stage.when.map((gate) => `includes([${gate.options.map(str).join(", ")}], ${left(gate.field)})`);
   const dated = (stage) => left(stage.field) === "now()" ? "true" : `!(${heldEmpty(stage.field, left(stage.field))})`;
   return validateBlock(
@@ -74571,10 +74630,11 @@ function milestoneOrder(stages, touches, left, words) {
         const written = touched.includes("true") ? [] : [touched.length === 1 ? touched[0] ?? "" : `(${touched.join(" || ")})`];
         const standing = [...written, dated(stage), ...applies(before)];
         return [
-          checkLine([...standing, heldEmpty(before.field, left(before.field))].filter((part) => part !== "true").join(" && "), stage.field.alias, str(words.refusals.milestoneOrder(stage.label, before.label))),
+          checkLine([...standing, heldEmpty(before.field, left(before.field))].filter((part) => part !== "true").join(" && "), landing(stage.field), str(words.refusals.milestoneOrder(stage.label, before.label))),
           checkLine(
-            [...standing, dated(before), `differenceInCalendarDays(${left(stage.field)}, ${left(before.field)}) < 0`].filter((part) => part !== "true").join(" && "),
-            stage.field.alias,
+            // No difference where either day is missing, which the tests before it already rule out.
+            [...standing, dated(before), `coalesce(differenceInCalendarDays(${left(stage.field)}, ${left(before.field)}), 0) < 0`].filter((part) => part !== "true").join(" && "),
+            landing(stage.field),
             str(words.refusals.milestoneBefore(stage.label, before.label))
           )
         ];
@@ -74582,12 +74642,17 @@ function milestoneOrder(stages, touches, left, words) {
     )
   );
 }
-function milestoneClears(stages, table, record2, sent) {
-  return stages.slice(0, -1).flatMap((stage, at2) => [
-    `if (${sent(stage.field.alias)} && isNull(i.${stage.field.alias})) {`,
-    `  await update_records({ table_id: ${str(table)}, record_ids: [${record2}], set: { ${stages.slice(at2 + 1).map((later) => `${str(later.field.id)}: null`).join(", ")} } });`,
-    `}`
-  ]);
+function milestoneClears(stages, table, record2, s) {
+  return stages.slice(0, -1).flatMap((stage, at2) => {
+    const sent = sends(s, stage.field);
+    if (sent === void 0) return [];
+    const later = stages.slice(at2 + 1).map((one) => `${str(one.field.id)}: null`);
+    return [
+      `if (${sent} && isNull(${s.from}.${stage.field.alias})) {`,
+      `  await update_records({ table_id: ${str(table)}, record_ids: [${record2}], set: { ${later.join(", ")} } });`,
+      `}`
+    ];
+  });
 }
 function picksGuard(picks, words) {
   return picks.flatMap((pick3) => {
@@ -74618,21 +74683,45 @@ function makeDocument(template, row) {
     `});`
   ];
 }
-function done(message2, data) {
-  return `return({ status: "success", message: ${str(message2)}${data === void 0 ? "" : `, data: ${data}`} });`;
+function done(message2, handed = {}) {
+  const keys2 = Object.keys(handed);
+  const data = keys2.length === 0 ? "" : `, data: { ${keys2.map((key) => `${key}: ${handed[key].value}`).join(", ")} }`;
+  return `return({ status: "success", message: ${str(message2)}${data} });`;
+}
+function handedOutputs(handed) {
+  return Object.fromEntries(Object.entries(handed).map(([key, one]) => [key, one.output]));
 }
+function handedRow(value, table) {
+  return { value, output: { type: "record_link", table_id: table } };
+}
+var HANDED_PAPER = {
+  file_id: { value: "paper.file_id", output: { type: "text" } },
+  url: { value: "paper.url", output: { type: "text" } },
+  filename: { value: "paper.filename", output: { type: "text" } }
+};
 
 // src/app_body_act.ts
 var MOVED_TO = "statusMovedTo";
+function actSending(plan) {
+  return {
+    from: "leaves",
+    carries: /* @__PURE__ */ new Set([...plan.set.map((one) => one.field.alias), ...plan.asks.filter((one) => !editedByDelta(one.field.field)).map((one) => one.field.alias)]),
+    inputs: /* @__PURE__ */ new Set([
+      ...plan.asks.flatMap((one) => editedByDelta(one.field.field) ? [deltaOf(one.field).added, deltaOf(one.field).removed] : [one.field.alias]),
+      ...plan.inputs.map((input) => input.name)
+    ]),
+    row: "row"
+  };
+}
 function actGates(plan) {
   const { words } = plan;
   const asked = new Set(plan.asks.map((one) => one.field.alias));
   const lacks = (need) => {
-    const held = `row.data[${str(need.field.id)}]`;
-    if (!asked.has(need.field.alias)) return heldEmpty(need.field, held);
-    if (!editedByDelta(need.field.field)) return heldEmpty(need.field, `(includes(keys(i), ${str(need.field.alias)}) ? i.${need.field.alias} : ${held})`);
+    const held2 = `row.data[${str(need.field.id)}]`;
+    if (!asked.has(need.field.alias)) return heldEmpty(need.field, held2);
+    if (!editedByDelta(need.field.field)) return heldEmpty(need.field, `(includes(keys(i), ${str(need.field.alias)}) ? i.${need.field.alias} : ${held2})`);
     const { added, removed } = deltaOf(need.field);
-    return `isEmpty(i.${added}) && size(i.${removed} ?? []) >= size(${held} ?? [])`;
+    return `isEmpty(i.${added}) && size(i.${removed} ?? []) >= size(${held2} ?? [])`;
   };
   const set2 = new Map(plan.set.map((one) => [one.field.id, one.value]));
   return [
@@ -74655,7 +74744,8 @@ function actGates(plan) {
       // What the act sets it always writes; what it asks, where the ask is answered.
       (field2) => set2.has(field2.id) ? "true" : asked.has(field2.alias) ? `includes(keys(i), ${str(field2.alias)})` : void 0,
       (field2) => set2.get(field2.id) ?? (asked.has(field2.alias) ? `(includes(keys(i), ${str(field2.alias)}) ? i.${field2.alias} : row.data[${str(field2.id)}])` : `row.data[${str(field2.id)}]`),
-      words
+      words,
+      (field2) => landsOn(actSending(plan), field2)
     )
   ];
 }
@@ -74674,7 +74764,7 @@ function actWrite(plan, record2) {
     const name = deltaOf(one.field).removed;
     return [
       `if (!isEmpty(i.${name})) {`,
-      `  await update_records({ table_id: ${str(plan.table.id)}, record_ids: [${record2}], remove_from: { ${str(one.field.id)}: i.${name} } });`,
+      `  await update_records({ table_id: ${str(plan.table.id)}, record_ids: [${record2}], remove_from: { ${str(one.field.id)}: i.${name} ?? [] } });`,
       `}`
     ];
   });
@@ -74717,22 +74807,27 @@ function actLeaves(plan) {
 }
 function actRules(plan, record2) {
   const { rules, words } = plan;
+  const sending = actSending(plan);
   return [
-    ...fieldBoundChecks(rules.bounded, words, "row", "leaves"),
-    ...heldGuards(rules.held, record2, words, "leaves"),
-    ...keptGuards(rules.kept, rules.written, words, "leaves"),
-    ...strayGuards(rules.strays, record2, words, "leaves"),
-    ...rules.overlap === void 0 ? [] : overlapGuard(rules.overlap, plan.table, words, { row: "row", record: record2 }, void 0, "leaves")
+    ...fieldBoundChecks(rules.bounded, words, sending),
+    ...heldGuards(rules.held, record2, words, sending),
+    ...keptGuards(rules.kept, rules.written, words, sending),
+    ...strayGuards(rules.strays, record2, words, sending),
+    ...rules.overlap === void 0 ? [] : overlapGuard(rules.overlap, plan.table, words, sending, record2)
   ];
 }
+function inputEmpty(type, value) {
+  if (type === "text" || type === "long_text") return `isEmpty(trim(coalesce(${value}, "")))`;
+  return type === "number" ? `isNull(${value})` : `isEmpty(${value})`;
+}
 function actInputChecks(plan) {
   const { words } = plan;
   return validateBlock([
-    ...plan.inputs.flatMap((input) => input.required ? [checkLine(`isEmpty(trim(coalesce(i.${input.name}, "")))`, input.name, str(words.refusals.required(input.label)))] : []),
+    ...plan.inputs.flatMap((input) => input.required ? [checkLine(inputEmpty(input.type, `i.${input.name}`), input.name, str(words.refusals.required(input.label)))] : []),
     ...plan.inputs.flatMap(
       (input) => input.options === void 0 ? [] : [checkLine(`!isNull(i.${input.name}) && !includes([${input.options.map(str).join(", ")}], i.${input.name})`, input.name, str(words.refusals.choice(input.label)))]
     ),
-    ...actRuled(plan) ? valueChecks(plan.rules.written, words, void 0, "leaves") : []
+    ...actRuled(plan) ? valueChecks(plan.rules.written, words, actSending(plan)) : []
   ]);
 }
 function actDocument(plan, record2) {
@@ -74789,9 +74884,9 @@ function actRegion(plan, authored = false) {
   ];
 }
 function actSource(plan) {
-  const handed = plan.template === void 0 ? void 0 : plan.on === "record" ? `{ record_id: i.${plan.param}, file_id: paper.file_id, url: paper.url, filename: paper.filename }` : `{ file_id: paper.file_id, url: paper.url, filename: paper.filename }`;
-  return `${[...actRegion(plan), done(plan.words.done.acted(plan.label), handed)].join("\n")}
-`;
+  const handed = plan.template === void 0 ? {} : plan.on === "record" ? { record_id: handedRow(`i.${plan.param}`, plan.table.id), ...HANDED_PAPER } : HANDED_PAPER;
+  return { source: `${[...actRegion(plan), done(plan.words.done.acted(plan.label), handed)].join("\n")}
+`, outputs: handedOutputs(handed) };
 }
 function exportSource(plan) {
   const lines = [
@@ -74807,10 +74902,10 @@ function exportSource(plan) {
     ]),
     `}`,
     ...makeDocument(plan.template, "row"),
-    done(plan.words.done.made(plan.template.label), `{ file_id: paper.file_id, url: paper.url, filename: paper.filename }`)
+    done(plan.words.done.made(plan.template.label), HANDED_PAPER)
   ];
-  return `${lines.join("\n")}
-`;
+  return { source: `${lines.join("\n")}
+`, outputs: handedOutputs(HANDED_PAPER) };
 }
 var GUARDS_START = "// <lotics:guards> Generated from the model by `lotics app regenerate` \u2014 edits between these lines are replaced.";
 var GUARDS_END = "// </lotics:guards> Your code follows.";
@@ -74845,13 +74940,19 @@ function createValue(field2) {
 }
 function createSource(plan) {
   const { words } = plan;
+  const handedFields = [...plan.fields.map((one) => one.field), ...plan.parent === void 0 ? [] : [plan.parent.field]];
+  const sending = {
+    from: "i",
+    carries: new Set(handedFields.filter((field2) => !editedByDelta(field2.field)).map((field2) => field2.alias)),
+    inputs: new Set(handedFields.map((field2) => editedByDelta(field2.field) ? deltaOf(field2).added : field2.alias))
+  };
   const lines = [`const i = trigger.app_workflow.inputs;`];
   lines.push(
     ...validateBlock([
       ...plan.fields.flatMap(
         (one) => one.required ? [checkLine(heldEmpty(one.field, createdInput(one.field)), one.field.alias, str(words.refusals.required(one.label)))] : []
       ),
-      ...valueChecks(plan.fields, words)
+      ...valueChecks(plan.fields, words, sending)
     ])
   );
   if (plan.parent !== void 0 && (plan.parent.table.scope !== void 0 || plan.parent.checks.length > 0)) {
@@ -74870,14 +74971,14 @@ function createSource(plan) {
         plan.milestones,
         (field2) => dates(field2) ? "true" : void 0,
         (field2) => asked.has(field2.id) ? createdInput(field2) : stamped.get(field2.id) === "now" ? "now()" : createdDefault(field2),
-        words
+        words,
+        (field2) => landsOn(sending, field2)
       )
     );
   }
-  lines.push(...fieldBoundChecks(plan.fields, words, void 0));
-  if (plan.overlap !== void 0) lines.push(...overlapGuard(plan.overlap, plan.table, words, void 0, new Set(plan.fields.map((one) => one.field.alias))));
-  const handed = /* @__PURE__ */ new Set([...plan.fields.map((one) => one.field.alias), ...plan.parent === void 0 ? [] : [plan.parent.field.alias]]);
-  for (const expect of plan.expects) lines.push(...expectGuard(expect, plan.table, words, void 0, handed));
+  lines.push(...fieldBoundChecks(plan.fields, words, sending));
+  if (plan.overlap !== void 0) lines.push(...overlapGuard(plan.overlap, plan.table, words, sending));
+  for (const expect of plan.expects) lines.push(...expectGuard(expect, plan.table, words, sending));
   for (const field2 of plan.unique) {
     const local = `${camel(field2.alias)}Taken`;
     lines.push(
@@ -74915,7 +75016,7 @@ function createSource(plan) {
     `    },`,
     `  ],`,
     `});`,
-    `opened = made.record_ids[0];`,
+    `const opened = made.record_ids[0];`,
     ...plan.history === void 0 ? [] : [
       `const openedRow = await get_record({ table_id: ${str(plan.table.id)}, record_id: opened });`,
       `if (!isNull(openedRow.data[${str(plan.history.source.id)}])) {`,
@@ -74923,10 +75024,13 @@ function createSource(plan) {
       `}`
     ]
   ];
+  const handing = (row, reused) => ({ record_id: handedRow(row, plan.table.id), reused: { value: String(reused), output: { type: "boolean" } } });
+  const outputs = handedOutputs(handing("opened", false));
+  const returned = done(words.done.opened(plan.table.label), handing("opened", false));
   if (plan.naturalKey.length === 0) {
-    lines.push(`let opened = null;`, ...opening, done(words.done.opened(plan.table.label), `{ record_id: opened, reused: false }`));
-    return `${lines.join("\n")}
-`;
+    lines.push(...opening, returned);
+    return { source: `${lines.join("\n")}
+`, outputs };
   }
   const conditions = plan.naturalKey.map(
     (field2) => field2.field.type === "select_record_link" ? `{ node_type: "condition", field_key: ${str(field2.id)}, operator: "has_any_of", value: [i.${field2.alias}] }` : `{ node_type: "condition", field_key: ${str(field2.id)}, operator: "equals", value: ${field2.field.type === "text" ? `trim(coalesce(i.${field2.alias}, ""))` : `i.${field2.alias}`} }`
@@ -74939,21 +75043,14 @@ function createSource(plan) {
     `});`,
     `const found = first(known.records);`,
     ...plan.table.scope === void 0 ? [] : validateBlock([checkLine(`!isNull(found) && !(${scopePasses(plan.table.scope, "found")})`, first2?.alias, str(words.refusals.taken(first2?.field.label ?? "")))]),
-    `let opened = null;`,
-    `if (isNull(found)) {`,
-    ...indent(opening),
-    `}`,
     `if (!isNull(found)) {`,
-    `  opened = found.id;`,
+    `  ${done(words.done.reused(plan.table.label), handing("found.id", true))}`,
     `}`,
-    `return({`,
-    `  status: "success",`,
-    `  message: isNull(found) ? ${str(words.done.opened(plan.table.label))} : ${str(words.done.reused(plan.table.label))},`,
-    `  data: { record_id: opened, reused: !isNull(found) },`,
-    `});`
+    ...opening,
+    returned
   );
-  return `${lines.join("\n")}
-`;
+  return { source: `${lines.join("\n")}
+`, outputs };
 }
 
 // src/app_body_update.ts
@@ -74961,15 +75058,22 @@ init_define_LOTICS_KIT_VERSIONS();
 function updateSource(plan) {
   const { words } = plan;
   const record2 = `i.${plan.param}`;
+  const handed = { record_id: handedRow(record2, plan.table.id) };
   const sent = (name) => `includes(keys(i), ${str(name)})`;
+  const sending = {
+    from: "i",
+    carries: new Set(plan.fields.filter((one) => !editedByDelta(one.field.field)).map((one) => one.field.alias)),
+    inputs: new Set(plan.fields.flatMap((one) => editedByDelta(one.field.field) ? [deltaOf(one.field).added, deltaOf(one.field).removed] : [one.field.alias])),
+    row: "row"
+  };
   const locked = plan.locks.some((lock) => lock.checks.length > 0);
   const readsRow = scopeReadsRow(plan.table.scope) || plan.checks.length > 0 || locked || plan.history !== void 0 || boundsByField(plan.bounded) || plan.overlap !== void 0 || plan.expects.length > 0 || plan.milestones.length > 0 || plan.kept.length > 0 || sameReadsRow(plan.fields);
   const saved = new Set(plan.fields.map((one) => one.field.id));
   const left = (field2) => {
-    const held = `(${sent(field2.alias)} ? i.${field2.alias} : row.data[${str(field2.id)}])`;
+    const held2 = leftBy(sending, field2);
     const at2 = plan.milestones.findIndex((stage) => stage.field.id === field2.id);
     const clears = plan.milestones.slice(0, Math.max(at2, 0)).filter((stage) => saved.has(stage.field.id)).map((stage) => `(${sent(stage.field.alias)} && isNull(i.${stage.field.alias}))`);
-    return clears.length === 0 ? held : `(${clears.join(" || ")} ? null : ${held})`;
+    return clears.length === 0 ? held2 : `(${clears.join(" || ")} ? null : ${held2})`;
   };
   const write = (op, name) => [
     `if (${sent(name)}) {`,
@@ -74994,32 +75098,35 @@ function updateSource(plan) {
       ...plan.fields.flatMap(
         (one) => !one.required || editedByDelta(one.field.field) ? [] : [checkLine(`${sent(one.field.alias)} && ${heldEmpty(one.field, `i.${one.field.alias}`)}`, one.field.alias, str(words.refusals.required(one.label)))]
       ),
-      ...valueChecks(plan.fields, words, sent)
+      ...valueChecks(plan.fields, words, sending)
     ]),
     ...readsRow ? [`const row = await get_record({ table_id: ${str(plan.table.id)}, record_id: ${record2} });`] : [],
     ...scopeGuard(plan.table, "row", words),
     ...checksGuard(plan.checks, "row"),
     ...locksGuard(plan.locks, "row", words),
-    ...fieldBoundChecks(plan.bounded, words, "row"),
-    ...heldGuards(plan.held, record2, words),
-    ...plan.overlap === void 0 ? [] : overlapGuard(plan.overlap, plan.table, words, { row: "row", record: record2 }),
-    ...plan.expects.flatMap((expect) => expectGuard(expect, plan.table, words, { row: "row", record: record2 })),
+    ...fieldBoundChecks(plan.bounded, words, sending),
+    ...heldGuards(plan.held, record2, words, sending),
+    ...plan.overlap === void 0 ? [] : overlapGuard(plan.overlap, plan.table, words, sending, record2),
+    ...plan.expects.flatMap((expect) => expectGuard(expect, plan.table, words, sending, record2)),
     // A `same` link compares with what the row names once the save lands: the value sent, else the one held.
-    ...linkChecks(plan.fields, words, (field2) => `(${sent(field2.alias)} ? i.${field2.alias} : first(row.data[${str(field2.id)}]))`),
-    ...keptGuards(plan.kept, plan.fields, words, "i"),
-    ...strayGuards(plan.strays, record2, words, "i"),
-    ...milestoneOrder(plan.milestones, (field2) => saved.has(field2.id) ? sent(field2.alias) : void 0, left, words),
+    ...linkChecks(plan.fields, words, (field2) => {
+      const moved = sends(sending, field2);
+      return moved === void 0 ? `first(row.data[${str(field2.id)}])` : `(${moved} ? i.${field2.alias} : first(row.data[${str(field2.id)}]))`;
+    }),
+    ...keptGuards(plan.kept, plan.fields, words, sending),
+    ...strayGuards(plan.strays, record2, words, sending),
+    ...milestoneOrder(plan.milestones, (field2) => saved.has(field2.id) ? sent(field2.alias) : void 0, left, words, (field2) => landsOn(sending, field2)),
     ...writes,
-    ...milestoneClears(plan.milestones, plan.table.id, record2, sent),
+    ...milestoneClears(plan.milestones, plan.table.id, record2, sending),
     ...history === void 0 ? [] : [
       `if (${sent(history.source.alias)} && i.${history.source.alias} != row.data[${str(history.source.id)}] && !isNull(i.${history.source.alias})) {`,
       ...indent(appendHistory(history, record2, `i.${history.source.alias}`)),
       `}`
     ],
-    done(words.done.updated(plan.table.label), `{ record_id: ${record2} }`)
+    done(words.done.updated(plan.table.label), handed)
   ];
-  return `${lines.join("\n")}
-`;
+  return { source: `${lines.join("\n")}
+`, outputs: handedOutputs(handed) };
 }
 function removeSource(plan) {
   const record2 = `i.${plan.param}`;
@@ -75033,8 +75140,8 @@ function removeSource(plan) {
     `await delete_records({ table_id: ${str(plan.table.id)}, record_ids: [${record2}] });`,
     done(plan.words.done.removed(plan.table.label))
   ];
-  return `${lines.join("\n")}
-`;
+  return { source: `${lines.join("\n")}
+`, outputs: {} };
 }
 
 // src/app_compile_context.ts
@@ -75660,10 +75767,10 @@ function historyCopies(ctx, act, entity, history) {
   const shape = historyShape(ctx.model, entity);
   if (shape === void 0 || "refused" in shape) return [];
   const taken = /* @__PURE__ */ new Set([shape.link, shape.status.field, shape.at.field, ...shape.by === void 0 ? [] : [shape.by]]);
-  const held = ctx.bound.entities.get(shape.entity)?.fields;
+  const held2 = ctx.bound.entities.get(shape.entity)?.fields;
   return act.asks.flatMap((ask) => {
     const name = typeof ask === "string" ? ask : ask.input;
-    const into = held?.get(name);
+    const into = held2?.get(name);
     if (into === void 0 || taken.has(name) || editedByDelta(into.field)) return [];
     if (typeof ask !== "string") return [{ into, value: inputInto(into, `i.${name}`) }];
     const from = fieldOf2(ctx, entity, name);
@@ -75730,7 +75837,7 @@ function actPlan(ctx, act) {
     requires: act.requires.map((name) => ({ field: fieldOf2(ctx, entity, name), label: label2(name) })),
     asks,
     inputs: act.asks.flatMap(
-      (ask) => typeof ask === "string" ? [] : [{ name: ask.input, label: ask.label, required: ask.required === true, ...ask.options === void 0 ? {} : { options: ask.options.map((option) => option.alias) } }]
+      (ask) => typeof ask === "string" ? [] : [{ name: ask.input, label: ask.label, type: ask.type, required: ask.required === true, ...ask.options === void 0 ? {} : { options: ask.options.map((option) => option.alias) } }]
     ),
     set: Object.entries(act.set).map(([name, value]) => {
       const bf = fieldOf2(ctx, entity, name);
@@ -75784,7 +75891,8 @@ function createInputs(ctx, alias2, writes) {
   const inputs = {};
   if (writes.parent !== void 0) {
     const via = fieldOf2(ctx, alias2, writes.parent);
-    inputs[via.alias] = fieldInput(ctx, via, true);
+    if (via.field.type !== "select_record_link") fail(`"${alias2}.${via.alias}" files a row under its record, so it must be a link`);
+    inputs[via.alias] = { type: "record_link", table_id: entityOf3(ctx, via.field.target_entity).table, required: true };
   }
   for (const name of writes.create ?? []) {
     const bf = fieldOf2(ctx, alias2, name);
@@ -76266,9 +76374,9 @@ function compileApp(model, app, bound, tables) {
   const written = /* @__PURE__ */ new Map();
   const deletes = /* @__PURE__ */ new Set();
   const wrote = (table, fields) => {
-    const held = written.get(table) ?? /* @__PURE__ */ new Set();
-    for (const field2 of fields) held.add(field2.id);
-    written.set(table, held);
+    const held2 = written.get(table) ?? /* @__PURE__ */ new Set();
+    for (const field2 of fields) held2.add(field2.id);
+    written.set(table, held2);
   };
   const entities = {};
   for (const alias2 of drawn.keys()) {
@@ -76282,8 +76390,9 @@ function compileApp(model, app, bound, tables) {
     if (writes?.create !== void 0) {
       const workflow = createAlias(alias2);
       const create = createPlan(ctx, alias2, writes);
-      bodies[workflow] = createSource(create);
-      workflows[workflow] = { inputs: createInputs(ctx, alias2, writes), description: described(words.workflows.create(bent.entity.label), bent.entity) };
+      const body = createSource(create);
+      bodies[workflow] = body.source;
+      workflows[workflow] = { inputs: createInputs(ctx, alias2, writes), outputs: body.outputs, description: described(words.workflows.create(bent.entity.label), bent.entity) };
       wrote(bent.table, [
         ...create.fields.map((one) => one.field),
         ...create.parent === void 0 ? [] : [create.parent.field],
@@ -76301,7 +76410,7 @@ function compileApp(model, app, bound, tables) {
       const overlap = bodyOverlap(ctx, alias2);
       const stages = bodyMilestones(ctx, alias2);
       const milestones = touchesMilestones(stages, new Set(fields.map((one) => one.field.alias))) ? stages : [];
-      bodies[workflow] = updateSource({
+      const body = updateSource({
         table,
         param: RECORD_INPUT,
         fields,
@@ -76317,15 +76426,21 @@ function compileApp(model, app, bound, tables) {
         milestones,
         words
       });
-      workflows[workflow] = { inputs: updateInputs(ctx, alias2, fields), description: described(words.workflows.update(bent.entity.label), bent.entity) };
+      bodies[workflow] = body.source;
+      workflows[workflow] = { inputs: updateInputs(ctx, alias2, fields), outputs: body.outputs, description: described(words.workflows.update(bent.entity.label), bent.entity) };
       wrote(bent.table, [...fields.map((one) => one.field), ...milestones.map((stage) => stage.field)]);
       if (moves !== void 0) wrote(moves.table, historyFields(moves));
       spec2.update = { workflow };
     }
     if (writes?.remove === true) {
       const workflow = removeAlias(alias2);
-      bodies[workflow] = removeSource({ table, param: RECORD_INPUT, checks: bodyChecks(ctx, "delete", alias2), locks: parentLocks(ctx, alias2), words });
-      workflows[workflow] = { inputs: { [RECORD_INPUT]: { type: "record_link", table_id: bent.table, required: true } }, description: described(words.workflows.remove(bent.entity.label), bent.entity) };
+      const body = removeSource({ table, param: RECORD_INPUT, checks: bodyChecks(ctx, "delete", alias2), locks: parentLocks(ctx, alias2), words });
+      bodies[workflow] = body.source;
+      workflows[workflow] = {
+        inputs: { [RECORD_INPUT]: { type: "record_link", table_id: bent.table, required: true } },
+        outputs: body.outputs,
+        description: described(words.workflows.remove(bent.entity.label), bent.entity)
+      };
       deletes.add(bent.table);
       spec2.remove = { workflow };
     }
@@ -76334,11 +76449,13 @@ function compileApp(model, app, bound, tables) {
   const acts = app.acts.map((act) => {
     const body = actPlan(ctx, act);
     const workflow = act.workflow ?? actAlias(act.alias);
-    if (act.workflow === void 0) bodies[workflow] = actSource(body);
-    else authored[workflow] = body;
+    const generated = act.workflow === void 0 ? actSource(body) : void 0;
+    if (generated === void 0) authored[workflow] = body;
+    else bodies[workflow] = generated.source;
     const on = entityOf3(ctx, actEntity(ctx.app, act)).entity;
     workflows[workflow] = {
       inputs: actInputs(ctx, act),
+      ...generated === void 0 ? {} : { outputs: generated.outputs },
       description: described(act.on === "record" ? words.workflows.act(act.label, on.label) : words.workflows.actOnRows(act.label, on.label), on)
     };
     wrote(body.table.id, [...body.set.map((one) => one.field), ...body.asks.map((one) => one.field), ...body.template?.into === void 0 ? [] : [body.template.into]]);
@@ -76350,10 +76467,12 @@ function compileApp(model, app, bound, tables) {
   if (exported !== void 0 && exported !== true) {
     const workflow = exportAlias(app.entity);
     const body = exportPlan(ctx, exported.template);
-    bodies[workflow] = exportSource(body);
+    const generated = exportSource(body);
+    bodies[workflow] = generated.source;
     const own = entityOf3(ctx, app.entity).entity;
     workflows[workflow] = {
       inputs: { [RECORDS_INPUT]: { type: "record_link", table_id: body.table.id, multi: true, max: RECORDS_INPUT_MAX, required: true } },
+      outputs: generated.outputs,
       description: described(words.workflows.export(body.template.label, own.label), own)
     };
     exportSpec = { workflow };
@@ -76512,8 +76631,8 @@ function writesDeclaration(queries, tables, written) {
   const aliased = codegenAliases(queries, tables);
   const out = {};
   for (const [table, fields] of written) {
-    const held = aliased.find((one) => one.table.id === table);
-    out[held?.alias ?? table] = [...fields].map((id) => held?.fields.find((one) => one.field.id === id)?.alias ?? id).sort();
+    const held2 = aliased.find((one) => one.table.id === table);
+    out[held2?.alias ?? table] = [...fields].map((id) => held2?.fields.find((one) => one.field.id === id)?.alias ?? id).sort();
   }
   return out;
 }
@@ -76593,15 +76712,16 @@ var projectionSchema = zod_default.object({
 function projectionOf(declaration) {
   const read2 = projectionSchema.safeParse(declaration?.ast);
   if (!read2.success) return void 0;
+  const columns = read2.data.columns.flatMap((column) => {
+    if (typeof column === "string") return [{ output: column, key: column }];
+    const key = typeof column.source === "string" ? column.source : void 0;
+    const output = column.output ?? key;
+    return output === void 0 ? [] : [{ output, ...key === void 0 ? {} : { key } }];
+  });
   return {
     table: read2.data.from.table_id,
-    outputs: new Set(
-      read2.data.columns.flatMap((column) => {
-        if (typeof column === "string") return [column];
-        if (column.output !== void 0) return [column.output];
-        return typeof column.source === "string" ? [column.source] : [];
-      })
-    )
+    outputs: new Set(columns.map((column) => column.output)),
+    keys: new Map(columns.flatMap((column) => column.key === void 0 ? [] : [[column.output, column.key]]))
   };
 }
 var paramsOf = (manifest, alias2) => new Set(Object.keys(manifest.queries?.[alias2]?.params ?? {}));
@@ -76635,6 +76755,8 @@ function checkRead(at2, read2, entity, manifest) {
   if (projection2.table !== entity.table) findings.push({ at: at2, message: `reads ${entity.label} (${entity.table}) through "${read2.query}", which reads ${projection2.table}` });
   for (const field2 of Object.values(entity.fields)) {
     if (!projection2.outputs.has(field2.alias)) findings.push({ at: at2, message: `draws "${field2.alias}" (${field2.label}), which "${read2.query}" does not project` });
+    const key = projection2.keys.get(field2.alias);
+    if (key !== void 0 && key !== field2.id) findings.push({ at: at2, message: `reads "${field2.alias}" as field \`${field2.id}\`, and "${read2.query}" projects it from \`${key}\`` });
     for (const [linked, column] of Object.entries(field2.face ?? {})) {
       if (!projection2.outputs.has(column)) findings.push({ at: at2, message: `draws the "${linked}" of the row "${field2.alias}" names under "${column}", which "${read2.query}" does not project` });
     }
@@ -76861,8 +76983,8 @@ export const components: RuntimeComponents = {};
 function buildAppFiles(app, compiled, existing) {
   const generated = Object.entries(compiled.bodies).map(([alias2, body]) => ({ path: workflowPath(alias2), content: body }));
   const authored = Object.entries(compiled.authored).map(([alias2, plan]) => {
-    const held = existing(workflowPath(alias2));
-    return { path: workflowPath(alias2), content: injectGuards(held === null ? null : stripWorkflowHeader(held), plan) };
+    const held2 = existing(workflowPath(alias2));
+    return { path: workflowPath(alias2), content: injectGuards(held2 === null ? null : stripWorkflowHeader(held2), plan) };
   });
   return [
     { path: APP_SPEC_PATH, content: `${JSON.stringify(compiled.spec, null, 2)}
@@ -79578,8 +79700,8 @@ function planFilterTraversal(filter2, aggregatedTableId, aggregatedFields, linke
   }
   const fieldMaps = /* @__PURE__ */ new Map();
   const fieldMapOf = (tableId2, fields) => {
-    const held = fieldMaps.get(tableId2);
-    if (held) return held;
+    const held2 = fieldMaps.get(tableId2);
+    if (held2) return held2;
     const byKey = {};
     for (const f of fields) byKey[f.key] = f;
     fieldMaps.set(tableId2, byKey);
@@ -80052,9 +80174,9 @@ function idsOf(cell) {
   });
 }
 function heldBy(records, tableId2) {
-  const held = records.get(tableId2);
-  if (held === void 0) throw new Error(`this model's tables do not include ${tableId2}`);
-  return held;
+  const held2 = records.get(tableId2);
+  if (held2 === void 0) throw new Error(`this model's tables do not include ${tableId2}`);
+  return held2;
 }
 function fieldsOf(fieldsByTable, tableId2) {
   const fields = fieldsByTable.get(tableId2);
@@ -80289,9 +80411,9 @@ function pairBack(field2, value, from, byRef, entityByAlias, tableByAlias, field
     if (typeof ref !== "string") continue;
     const linked = byRef.get(ref);
     if (linked === void 0) continue;
-    const held = readLinkCell(linked.cells.get(partnerKey));
-    if (held.some((one) => one.id === from.id)) continue;
-    linked.cells.set(partnerKey, [...held, { id: from.id, display: "" }]);
+    const held2 = readLinkCell(linked.cells.get(partnerKey));
+    if (held2.some((one) => one.id === from.id)) continue;
+    linked.cells.set(partnerKey, [...held2, { id: from.id, display: "" }]);
   }
 }
 function readLinkCell(cell) {
@@ -80360,20 +80482,20 @@ function buildDisplays(entities, display, records, tableByAlias, fieldsByTable)
     heldBy(records, table.id).forEach((record2, r) => cellOf.set(record2.id, { entity, record: record2, r, key: at2 === -1 ? void 0 : fields[at2]?.key, link }));
   }
   const nameOf2 = (id, seen) => {
-    const held = cellOf.get(id);
-    if (held === void 0 || seen.has(id)) return void 0;
-    const stated2 = held.key === void 0 ? void 0 : held.record.cells.get(held.key);
-    if (held.link) {
+    const held2 = cellOf.get(id);
+    if (held2 === void 0 || seen.has(id)) return void 0;
+    const stated2 = held2.key === void 0 ? void 0 : held2.record.cells.get(held2.key);
+    if (held2.link) {
       const through = readLinkCell(stated2)[0];
       const name = through === void 0 ? void 0 : nameOf2(through.id, /* @__PURE__ */ new Set([...seen, id]));
       if (name !== void 0) return name;
     } else if (typeof stated2 === "string" && stated2 !== "") return stated2;
-    return `${held.entity.singular ?? held.entity.label} ${held.r + 1}`;
+    return `${held2.entity.singular ?? held2.entity.label} ${held2.r + 1}`;
   };
   return new Map([...cellOf.keys()].map((id) => [id, nameOf2(id, /* @__PURE__ */ new Set()) ?? id]));
 }
 function fillLinkDisplays(records, displays, fieldsByTable) {
-  for (const [tableId2, held] of records) {
+  for (const [tableId2, held2] of records) {
     const linking = new Set(
       (fieldsByTable.get(tableId2) ?? []).filter((field2) => field2.type === "select_record_link" || field2.type === "lookup" && field2.lookup_field_type === "select_record_link").map((field2) => field2.key)
     );
@@ -80382,14 +80504,14 @@ function fillLinkDisplays(records, displays, fieldsByTable) {
       const links = readLinkCell(cell);
       return links.length === 0 ? cell : links.map((link) => ({ id: link.id, display: displays.get(link.id) ?? link.id }));
     };
-    for (const record2 of held) {
+    for (const record2 of held2) {
       for (const [key, cell] of record2.cells) {
         if (linking.has(key)) record2.cells.set(key, named(cell));
       }
     }
   }
 }
-function narrowings(filter2, held) {
+function narrowings(filter2, held2) {
   const found = {};
   const visit2 = (node) => {
     if (node === null || typeof node !== "object") return;
@@ -80405,12 +80527,12 @@ function narrowings(filter2, held) {
     const operator = Reflect.get(node, "operator");
     const days = (side) => {
       if (typeof fieldKey !== "string") return void 0;
-      return { side, day: Object.fromEntries(held.flatMap((record2) => {
+      return { side, day: Object.fromEntries(held2.flatMap((record2) => {
         const day = dayOf2(record2.cells.get(fieldKey));
         return day === null ? [] : [[record2.id, day]];
       })) };
     };
-    const by = type === "record_id" ? { own: operator === "is_none_of" ? "not" : "is" } : operator === "on_or_after" ? days("from") : operator === "on_or_before" ? days("to") : typeof fieldKey === "string" ? { holds: Object.fromEntries(held.map((record2) => [record2.id, idsOf(record2.cells.get(fieldKey))])) } : void 0;
+    const by = type === "record_id" ? { own: operator === "is_none_of" ? "not" : "is" } : operator === "on_or_after" ? days("from") : operator === "on_or_before" ? days("to") : typeof fieldKey === "string" ? { holds: Object.fromEntries(held2.map((record2) => [record2.id, idsOf(record2.cells.get(fieldKey))])) } : void 0;
     if (by === void 0) return;
     for (const token2 of tokens) found[token2] = [...found[token2] ?? [], by];
   };
@@ -80448,12 +80570,12 @@ function census(entities, tableByAlias, records, fieldsByTable) {
   for (const entity of entities) {
     const table = tableByAlias.get(entity.alias);
     if (table === void 0) continue;
-    const held = heldBy(records, table.id);
-    if (held.length === 0) continue;
+    const held2 = heldBy(records, table.id);
+    if (held2.length === 0) continue;
     const fields = fieldsOf(fieldsByTable, table.id);
     entity.fields.forEach((field2, f) => {
       if (!COMPUTED.has(field2.type)) return;
-      const cells = held.map((record2) => record2.cells.get(fields[f].key));
+      const cells = held2.map((record2) => record2.cells.get(fields[f].key));
       const named = `${entity.alias}.${field2.alias} (${field2.type})`;
       if (cells.some(holdsFormulaError)) errored.push(named);
       else if (cells.every(isEmptyFieldValue)) unfilled.push(named);
@@ -80522,10 +80644,10 @@ function computeDerived(order, tableByAlias, records, fieldsByTable) {
       contexts.set(table.id, context);
     }
     const linkedRecords = new Map(
-      [...records].map(([id, held2]) => [id, held2.map(asTableRecord)])
+      [...records].map(([id, held3]) => [id, held3.map(asTableRecord)])
     );
-    const held = heldBy(records, table.id);
-    const computed = held.map(
+    const held2 = heldBy(records, table.id);
+    const computed = held2.map(
       (record2) => computeFormulaFieldsWithContext(
         Object.fromEntries(record2.cells),
         fields,
@@ -80537,7 +80659,7 @@ function computeDerived(order, tableByAlias, records, fieldsByTable) {
         linkExpanded
       )[key]
     );
-    held.forEach((record2, r) => {
+    held2.forEach((record2, r) => {
       const value = computed[r];
       if (value === void 0) record2.cells.delete(key);
       else record2.cells.set(key, value);
@@ -82796,8 +82918,8 @@ function reusesInstall(project2) {
   const stamp = `${project2.dir}.json`;
   if (!fs23.existsSync(path24.join(project2.dir, "node_modules", "vite", "bin", "vite.js"))) return false;
   if (!fs23.existsSync(stamp)) return false;
-  const held = stampSchema.safeParse(parseJson2(fs23.readFileSync(stamp, "utf8")));
-  return held.success && JSON.stringify(sortedStamp(held.data)) === JSON.stringify(sortedStamp(project2.stamp));
+  const held2 = stampSchema.safeParse(parseJson2(fs23.readFileSync(stamp, "utf8")));
+  return held2.success && JSON.stringify(sortedStamp(held2.data)) === JSON.stringify(sortedStamp(project2.stamp));
 }
 function sortedStamp(stamp) {
   return { key: stamp.key, tarballs: sorted(stamp.tarballs) };
@@ -83116,8 +83238,8 @@ async function appPreview(args) {
     rmSync2(staging, { recursive: true, force: true });
   }
 }
-async function previewIn(args, held) {
-  const { plan, project: project2, widths, timed, phases, specs, kits } = held;
+async function previewIn(args, held2) {
+  const { plan, project: project2, widths, timed, phases, specs, kits } = held2;
   const projectDir = project2.dir;
   const bundle = probeBundle();
   if (args.shots !== void 0) mkdirSync2(args.shots, { recursive: true });
@@ -83144,7 +83266,7 @@ async function previewIn(args, held) {
         screens: args.screens,
         shots: args.shots,
         sleep: sleep5,
-        ...held.record === void 0 ? {} : { record: held.record }
+        ...held2.record === void 0 ? {} : { record: held2.record }
       });
     } finally {
       await dev.stop();
@@ -85062,8 +85184,8 @@ function planGeneration(projectDir, generated, retiredWorkflows) {
   }
   for (const alias2 of retiredWorkflows) {
     const relative3 = `${WORKFLOW_DIR}${alias2}${WORKFLOW_SUFFIX}`;
-    const held = read(projectDir, relative3);
-    if (held === null || held.includes(GUARDS_START)) continue;
+    const held2 = read(projectDir, relative3);
+    if (held2 === null || held2.includes(GUARDS_START)) continue;
     deletes.push(relative3);
     outcomes.push({ path: relative3, kind: "deleted" });
   }
@@ -85141,12 +85263,12 @@ function plannedWorkflowBodies(projectDir, plan, declared) {
     const alias2 = workflowAlias(write.path);
     if (alias2 !== null) sources.set(alias2, write.content);
   }
-  const held = [...sources].map(([alias2, source]) => ({
+  const held2 = [...sources].map(([alias2, source]) => ({
     alias: alias2,
     source: stripWorkflowHeader(source)
   }));
   const missing = declared.filter((alias2) => !sources.has(alias2)).map((alias2) => ({ alias: alias2, source: null }));
-  return [...held, ...missing].sort((a, b) => a.alias < b.alias ? -1 : a.alias > b.alias ? 1 : 0);
+  return [...held2, ...missing].sort((a, b) => a.alias < b.alias ? -1 : a.alias > b.alias ? 1 : 0);
 }
 function brandingDrift(app, live) {
   const color = app.theme?.color ?? null;
@@ -85246,13 +85368,14 @@ async function foldRegeneration(client, args = {}) {
         // business reissuing it, and dropping it makes the next push read as a
         // new bind.
         ...previous.workflow_id === void 0 ? {} : { workflow_id: previous.workflow_id },
-        // The `outputs` the server DERIVED from a body this generation does not
-        // rewrite. The generator declares none, so `workflow set` writes the
-        // derivation back into the manifest — and a run that dropped it left the
-        // declaration disagreeing with the live binding over a schema nobody
-        // changed, which re-reported and re-pushed the same alias for ever. A
-        // body this run DOES rewrite loses it: the derivation belonged to the
-        // body it was derived from, and the next push re-derives it.
+        // A generated body's `outputs` are the generator's, declared as its
+        // return hands them. An AUTHORED act's are the ones the server DERIVED
+        // from its body, which `workflow set` writes back into the manifest — and
+        // a run that dropped them left the declaration disagreeing with the live
+        // binding over a schema nobody changed, which re-reported and re-pushed
+        // the same alias for ever. A body this run DOES rewrite loses them: the
+        // derivation belonged to the body it was derived from, and the next push
+        // re-derives it.
         ...next.outputs === void 0 && previous.outputs !== void 0 && !rewrittenBodies.has(alias2) ? { outputs: previous.outputs } : {}
       };
     }