@prestack/thread 0.1.7 → 0.1.8

package/dist/operations/generators/compile.js

@@ -152,7 +152,8 @@ function answers(node, found) {
         answers(one, found);
     });
 }
-function spliced(text, names, mine, roles) {
+function spliced(text, shape, roles) {
+    const { names, mine } = shape;
     const read = arrowIn(text, roles);
     if (typeof read === 'string')
         return read;
@@ -190,6 +191,7 @@ function spliced(text, names, mine, roles) {
                     return;
                 }
                 edits.push({ from: up.getStart(), to: up.getEnd(), text: said });
+                shape.heard.add(said);
                 return;
             }
             because = `reaches for \`${read.held}\` itself rather than one thing on it, and once every node is a local there is no such thing to hand it`;
@@ -232,19 +234,20 @@ function spliced(text, names, mine, roles) {
     return { form: 'call', text: whole, whole };
 }
 const ANSWERS = `${OWN}ANSWER`;
-function answered(name, one, opened, kind) {
+const linesOf = (one, name, unread) => (unread ? `${one.text.replace(`${ANSWERS} = `, 'void (')})` : one.text.replace(ANSWERS, name)).split('\n');
+function answered(name, one, opened, kind, unread) {
     if (one.form === 'expression')
-        return [`${kind} ${name}: unknown = ${one.text}`];
+        return [unread ? `void (${one.text})` : `${kind} ${name}: unknown = ${one.text}`];
     if (one.form === 'statements') {
-        return [`let ${name}: unknown`, '{', ...one.text.split('\n').map((line) => `  ${line.replace(ANSWERS, name)}`), '}'];
+        return [...(unread ? [] : [`let ${name}: unknown`]), '{', ...linesOf(one, name, unread).map((line) => `  ${line}`), '}'];
     }
-    return [`${kind} ${name}: unknown = await ${asFn(one.whole, opened)}(opened)`];
+    return [`${unread ? '' : `${kind} ${name}: unknown = `}await ${asFn(one.whole, opened)}(opened)`];
 }
 const asFn = (text, opened, more = '') => `((${text}) as (${more}opened: ${opened}) => Promise<unknown>)`;
 function forked(name, said, shape) {
     if (said.length !== 2)
         return `takes a chooser and the ways it chooses between, and was handed ${String(said.length)} thing(s)`;
-    const chose = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.block);
+    const chose = spliced(said[0] ?? '', shape, ROLES.block);
     if (typeof chose === 'string')
         return `chooses with a block that ${chose}`;
     const held = inside(said[1] ?? '', '{', '}');
@@ -252,25 +255,26 @@ function forked(name, said, shape) {
     const named = ways?.every((one) => one !== undefined && PLAIN.test(one.key)) === true ? ways : undefined;
     if (named === undefined || named.length === 0)
         return 'names its ways in a way this cannot read — write each one as `name: block`';
+    const unread = shape.unread.has(name);
     const picked = `${OWN}${name}_said`;
     const runs = [
-        `let ${name}: unknown`,
+        ...(unread ? [] : [`let ${name}: unknown`]),
         chose.form === 'expression'
             ? `const ${picked}: string = await (${chose.text})`
             : `const ${picked}: string = await ((${said[0] ?? ''}) as (opened: ${shape.reads}) => Promise<string>)(opened)`,
         `switch (${picked}) {`,
     ];
     for (const way of named) {
-        const each = spliced(way?.held ?? '', shape.names, shape.mine, ROLES.block);
+        const each = spliced(way?.held ?? '', shape, ROLES.block);
         if (typeof each === 'string')
             return `has a way \`${way?.key ?? ''}\` that ${each}`;
         runs.push(`  case ${(way?.key ?? '').startsWith("'") ? (way?.key ?? '') : quoted(way?.key ?? '')}: {`);
         if (each.form === 'expression')
-            runs.push(`    ${name} = ${each.text}`);
+            runs.push(unread ? `    void (${each.text})` : `    ${name} = ${each.text}`);
         else if (each.form === 'statements')
-            runs.push(...each.text.split('\n').map((line) => `    ${line.replace(ANSWERS, name)}`));
+            runs.push(...linesOf(each, name, unread).map((line) => `    ${line}`));
         else
-            runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(opened)`);
+            runs.push(`    ${unread ? '' : `${name} = `}await ${asFn(each.whole, shape.all)}(opened)`);
         runs.push('    break');
         runs.push('  }');
     }
@@ -285,23 +289,24 @@ const SHAPES = {
     nd_each: (name, said, shape) => {
         if (said.length !== 2)
             return `takes what to run over and the block to run, and was handed ${String(said.length)} thing(s)`;
-        const over = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.over);
-        const block = spliced(said[1] ?? '', shape.names, shape.mine, ROLES.item);
+        const over = spliced(said[0] ?? '', shape, ROLES.over);
+        const block = spliced(said[1] ?? '', shape, ROLES.item);
         if (typeof block === 'string')
             return `runs a block that ${block}`;
         if (typeof over === 'string')
             return `runs over a block that ${over}`;
+        const unread = shape.unread.has(name);
         const item = `${OWN}${name}_item`;
         const all = `${OWN}${name}_all`;
         const each = `${OWN}${name}_each`;
         return {
             runs: [
-                `const ${all}: unknown[] = []`,
+                ...(unread ? [] : [`const ${all}: unknown[] = []`]),
                 `const ${each} = (${block.whole}) as (item: unknown, opened: ${shape.all}) => Promise<unknown>`,
                 `for (const ${item} of ${over.form === 'expression' ? `(${over.text})` : `((${over.whole}) as () => readonly unknown[])()`} as readonly unknown[]) {`,
-                `  ${all}.push(await ${each}(${item}, opened))`,
+                unread ? `  await ${each}(${item}, opened)` : `  ${all}.push(await ${each}(${item}, opened))`,
                 '}',
-                `const ${name}: unknown = ${all}`,
+                ...(unread ? [] : [`const ${name}: unknown = ${all}`]),
             ],
         };
     },
@@ -316,17 +321,17 @@ const SHAPES = {
             return 'was handed no blocks to run at once';
         const calls = [];
         for (const [order, one] of every.entries()) {
-            const each = spliced(one, shape.names, shape.mine, ROLES.block);
+            const each = spliced(one, shape, ROLES.block);
             if (typeof each === 'string')
                 return `runs a block at position ${String(order + 1)} that ${each}`;
             calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(opened)`);
         }
-        return { runs: [`const ${name}: unknown = await Promise.all([${calls.join(', ')}])`] };
+        return { runs: [`${shape.unread.has(name) ? '' : `const ${name}: unknown = `}await Promise.all([${calls.join(', ')}])`] };
     },
     nd_repeat: (name, said, shape) => {
         if (said.length !== 2)
             return `takes a ceiling and the block to repeat, and was handed ${String(said.length)} thing(s)`;
-        const block = spliced(said[1] ?? '', shape.names, shape.mine, ROLES.again);
+        const block = spliced(said[1] ?? '', shape, ROLES.again);
         if (typeof block === 'string')
             return `repeats a block that ${block}`;
         const ceiling = `${OWN}${name}_ceiling`;
@@ -335,16 +340,17 @@ const SHAPES = {
         const done = `${OWN}${name}_done`;
         const pass = `${OWN}${name}_pass`;
         const answer = `${OWN}${name}_said`;
+        const unread = shape.unread.has(name);
         return {
             runs: [
-                `let ${name}: unknown`,
+                ...(unread ? [] : [`let ${name}: unknown`]),
                 `const ${ceiling}: number = ${said[0] ?? ''}`,
                 `const ${again} = (${block.whole}) as (pass: number, carried: unknown, opened: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
                 `let ${carried}: unknown`,
                 `let ${done} = false`,
                 `for (let ${pass} = 0; ${pass} < ${ceiling}; ${pass} += 1) {`,
                 `  const ${answer} = await ${again}(${pass}, ${carried}, opened)`,
-                `  if (${answer}.done) { ${name} = ${answer}.value; ${done} = true; break }`,
+                `  if (${answer}.done) { ${unread ? '' : `${name} = ${answer}.value; `}${done} = true; break }`,
                 `  ${carried} = ${answer}.value`,
                 '}',
                 `if (!${done}) throw new Error(\`${name} reached its ceiling of \${String(${ceiling})} passes without answering done\`)`,
@@ -357,21 +363,22 @@ const STOPS = "Symbol.for('thread.operation.stopped')";
 function plainly(name, said, shape, opened, ends) {
     if (said.length !== 1)
         return `takes one block, and was handed ${String(said.length)} thing(s)`;
-    const one = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.block);
+    const one = spliced(said[0] ?? '', shape, ROLES.block);
     if (typeof one === 'string')
         return one;
+    const unread = shape.unread.has(name);
     if (!ends)
-        return { runs: answered(name, one, opened, 'const') };
+        return { runs: answered(name, one, opened, 'const', unread) };
     return {
         runs: [
-            ...answered(name, one, opened, 'const'),
+            ...answered(name, one, opened, 'const', unread),
             `throw Object.assign(new Error(${quoted(`${name} ended the operation`)}), { [${STOPS}]: true, value: ${name} })`,
         ],
     };
 }
 const saidIn = (held) => held !== undefined && ts.isStringLiteral(held) ? held.text : undefined;
 const sourceIn = (held) => held?.getText();
-function compiled(at, id, one, known) {
+function compiled(at, id, one, known, unread) {
     const because = problem(id, one);
     if (because !== undefined)
         return { because };
@@ -394,6 +401,7 @@ function compiled(at, id, one, known) {
     const mine = new Set(['input', ...one.nodes.map((row) => String(row.id))]);
     const runs = [];
     const names = new Set();
+    const heard = new Set();
     let last;
     for (const [order, row] of one.nodes.entries()) {
         const name = row.id;
@@ -418,7 +426,7 @@ function compiled(at, id, one, known) {
         if (held === undefined) {
             return { because: `the node \`${name}\` states no block this can read in ${row.at} — run \`thread seed\` and write it again` };
         }
-        const shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine };
+        const shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine, heard, unread: unread ?? new Set() };
         const made = (SHAPES[from] ?? ownType)(name, parts(held), shape);
         if (typeof made === 'string')
             return { because: `the node \`${name}\` ${made}` };
@@ -428,12 +436,17 @@ function compiled(at, id, one, known) {
         names.add(name);
         last = from === 'nd_stop' ? undefined : name;
     }
+    if (unread === undefined) {
+        const final = one.nodes.at(-1)?.id;
+        return compiled(at, id, one, known, new Set([...mine].filter((name) => name !== final && !heard.has(name))));
+    }
+    const typed = ['Opened', 'Reads'].filter((word) => runs.some((line) => line.includes(`${word}<`)));
     return {
         text: [
             "import type { z } from 'zod'",
             '',
             `import type { Operation } from ${quoted(runtime(at, '../operations.ts'))}`,
-            'import type { Opened, Reads } from ' + quoted(runtime(at, '../operations.ts')),
+            ...(typed.length === 0 ? [] : [`import type { ${typed.join(', ')} } from ${quoted(runtime(at, '../operations.ts'))}`]),
             '',
             `import { input, resource } from ${quoted(beside(at, takes))}`,
             '',
@@ -448,7 +461,7 @@ function compiled(at, id, one, known) {
             ...(quota === undefined ? [] : [`  quota: ${quota},`]),
             '',
             '  run: async (opened, held) => {',
-            '    const input = held.input',
+            ...(unread.has('input') ? [] : ['    const input = held.input']),
             `    let ${ENTERED} = ''`,
             '    try {',
             ...runs,

package/dist/operations/generators/compile.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-import { dirname, resolve } from 'node:path'
+import { resolve } from 'node:path'
 import { argv, stdout } from 'node:process'
 
 import ts from 'typescript'
@@ -190,12 +190,8 @@ interface Spliced {
   readonly whole: string
 }
 
-function spliced(
-  text: string,
-  names: ReadonlySet<string>,
-  mine: ReadonlySet<string>,
-  roles: readonly string[],
-): Spliced | string {
+function spliced(text: string, shape: Shape, roles: readonly string[]): Spliced | string {
+  const { names, mine } = shape
   const read = arrowIn(text, roles)
   if (typeof read === 'string') return read
 
@@ -243,6 +239,7 @@ function spliced(
           return
         }
         edits.push({ from: up.getStart(), to: up.getEnd(), text: said })
+        shape.heard.add(said)
         return
       }
       because = `reaches for \`${read.held}\` itself rather than one thing on it, and once every node is a local there is no such thing to hand it`
@@ -300,14 +297,19 @@ interface Shape {
   readonly reads: string
   readonly names: ReadonlySet<string>
   readonly mine: ReadonlySet<string>
+  readonly heard: Set<string>
+  readonly unread: ReadonlySet<string>
 }
 
-function answered(name: string, one: Spliced, opened: string, kind: 'const' | 'let'): readonly string[] {
-  if (one.form === 'expression') return [`${kind} ${name}: unknown = ${one.text}`]
+const linesOf = (one: Spliced, name: string, unread: boolean): readonly string[] =>
+  (unread ? `${one.text.replace(`${ANSWERS} = `, 'void (')})` : one.text.replace(ANSWERS, name)).split('\n')
+
+function answered(name: string, one: Spliced, opened: string, kind: 'const' | 'let', unread: boolean): readonly string[] {
+  if (one.form === 'expression') return [unread ? `void (${one.text})` : `${kind} ${name}: unknown = ${one.text}`]
   if (one.form === 'statements') {
-    return [`let ${name}: unknown`, '{', ...one.text.split('\n').map((line) => `  ${line.replace(ANSWERS, name)}`), '}']
+    return [...(unread ? [] : [`let ${name}: unknown`]), '{', ...linesOf(one, name, unread).map((line) => `  ${line}`), '}']
   }
-  return [`${kind} ${name}: unknown = await ${asFn(one.whole, opened)}(opened)`]
+  return [`${unread ? '' : `${kind} ${name}: unknown = `}await ${asFn(one.whole, opened)}(opened)`]
 }
 
 const asFn = (text: string, opened: string, more: string = ''): string =>
@@ -316,7 +318,7 @@ const asFn = (text: string, opened: string, more: string = ''): string =>
 function forked(name: string, said: readonly string[], shape: Shape): Made | string {
   if (said.length !== 2) return `takes a chooser and the ways it chooses between, and was handed ${String(said.length)} thing(s)`
 
-  const chose = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.block)
+  const chose = spliced(said[0] ?? '', shape, ROLES.block)
   if (typeof chose === 'string') return `chooses with a block that ${chose}`
 
   const held = inside(said[1] ?? '', '{', '}')
@@ -324,9 +326,10 @@ function forked(name: string, said: readonly string[], shape: Shape): Made | str
   const named = ways?.every((one) => one !== undefined && PLAIN.test(one.key)) === true ? ways : undefined
   if (named === undefined || named.length === 0) return 'names its ways in a way this cannot read — write each one as `name: block`'
 
+  const unread = shape.unread.has(name)
   const picked = `${OWN}${name}_said`
   const runs = [
-    `let ${name}: unknown`,
+    ...(unread ? [] : [`let ${name}: unknown`]),
     chose.form === 'expression'
       ? `const ${picked}: string = await (${chose.text})`
       : `const ${picked}: string = await ((${said[0] ?? ''}) as (opened: ${shape.reads}) => Promise<string>)(opened)`,
@@ -334,12 +337,12 @@ function forked(name: string, said: readonly string[], shape: Shape): Made | str
   ]
 
   for (const way of named) {
-    const each = spliced(way?.held ?? '', shape.names, shape.mine, ROLES.block)
+    const each = spliced(way?.held ?? '', shape, ROLES.block)
     if (typeof each === 'string') return `has a way \`${way?.key ?? ''}\` that ${each}`
     runs.push(`  case ${(way?.key ?? '').startsWith("'") ? (way?.key ?? '') : quoted(way?.key ?? '')}: {`)
-    if (each.form === 'expression') runs.push(`    ${name} = ${each.text}`)
-    else if (each.form === 'statements') runs.push(...each.text.split('\n').map((line) => `    ${line.replace(ANSWERS, name)}`))
-    else runs.push(`    ${name} = await ${asFn(each.whole, shape.all)}(opened)`)
+    if (each.form === 'expression') runs.push(unread ? `    void (${each.text})` : `    ${name} = ${each.text}`)
+    else if (each.form === 'statements') runs.push(...linesOf(each, name, unread).map((line) => `    ${line}`))
+    else runs.push(`    ${unread ? '' : `${name} = `}await ${asFn(each.whole, shape.all)}(opened)`)
     runs.push('    break')
     runs.push('  }')
   }
@@ -356,21 +359,22 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
 
   nd_each: (name, said, shape) => {
     if (said.length !== 2) return `takes what to run over and the block to run, and was handed ${String(said.length)} thing(s)`
-    const over = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.over)
-    const block = spliced(said[1] ?? '', shape.names, shape.mine, ROLES.item)
+    const over = spliced(said[0] ?? '', shape, ROLES.over)
+    const block = spliced(said[1] ?? '', shape, ROLES.item)
     if (typeof block === 'string') return `runs a block that ${block}`
     if (typeof over === 'string') return `runs over a block that ${over}`
+    const unread = shape.unread.has(name)
     const item = `${OWN}${name}_item`
     const all = `${OWN}${name}_all`
     const each = `${OWN}${name}_each`
     return {
       runs: [
-        `const ${all}: unknown[] = []`,
+        ...(unread ? [] : [`const ${all}: unknown[] = []`]),
         `const ${each} = (${block.whole}) as (item: unknown, opened: ${shape.all}) => Promise<unknown>`,
         `for (const ${item} of ${over.form === 'expression' ? `(${over.text})` : `((${over.whole}) as () => readonly unknown[])()`} as readonly unknown[]) {`,
-        `  ${all}.push(await ${each}(${item}, opened))`,
+        unread ? `  await ${each}(${item}, opened)` : `  ${all}.push(await ${each}(${item}, opened))`,
         '}',
-        `const ${name}: unknown = ${all}`,
+        ...(unread ? [] : [`const ${name}: unknown = ${all}`]),
       ],
     }
   },
@@ -384,16 +388,16 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
 
     const calls: string[] = []
     for (const [order, one] of every.entries()) {
-      const each = spliced(one, shape.names, shape.mine, ROLES.block)
+      const each = spliced(one, shape, ROLES.block)
       if (typeof each === 'string') return `runs a block at position ${String(order + 1)} that ${each}`
       calls.push(each.form === 'expression' ? `(async () => ${each.text})()` : `${asFn(each.whole, shape.all)}(opened)`)
     }
-    return { runs: [`const ${name}: unknown = await Promise.all([${calls.join(', ')}])`] }
+    return { runs: [`${shape.unread.has(name) ? '' : `const ${name}: unknown = `}await Promise.all([${calls.join(', ')}])`] }
   },
 
   nd_repeat: (name, said, shape) => {
     if (said.length !== 2) return `takes a ceiling and the block to repeat, and was handed ${String(said.length)} thing(s)`
-    const block = spliced(said[1] ?? '', shape.names, shape.mine, ROLES.again)
+    const block = spliced(said[1] ?? '', shape, ROLES.again)
     if (typeof block === 'string') return `repeats a block that ${block}`
     const ceiling = `${OWN}${name}_ceiling`
     const again = `${OWN}${name}_again`
@@ -401,16 +405,17 @@ const SHAPES: Readonly<Record<string, (name: string, said: readonly string[], sh
     const done = `${OWN}${name}_done`
     const pass = `${OWN}${name}_pass`
     const answer = `${OWN}${name}_said`
+    const unread = shape.unread.has(name)
     return {
       runs: [
-        `let ${name}: unknown`,
+        ...(unread ? [] : [`let ${name}: unknown`]),
         `const ${ceiling}: number = ${said[0] ?? ''}`,
         `const ${again} = (${block.whole}) as (pass: number, carried: unknown, opened: ${shape.all}) => Promise<{ readonly done: boolean; readonly value: unknown }>`,
         `let ${carried}: unknown`,
         `let ${done} = false`,
         `for (let ${pass} = 0; ${pass} < ${ceiling}; ${pass} += 1) {`,
         `  const ${answer} = await ${again}(${pass}, ${carried}, opened)`,
-        `  if (${answer}.done) { ${name} = ${answer}.value; ${done} = true; break }`,
+        `  if (${answer}.done) { ${unread ? '' : `${name} = ${answer}.value; `}${done} = true; break }`,
         `  ${carried} = ${answer}.value`,
         '}',
         `if (!${done}) throw new Error(\`${name} reached its ceiling of \${String(${ceiling})} passes without answering done\`)`,
@@ -425,14 +430,15 @@ const STOPS = "Symbol.for('thread.operation.stopped')"
 
 function plainly(name: string, said: readonly string[], shape: Shape, opened: string, ends: boolean): Made | string {
   if (said.length !== 1) return `takes one block, and was handed ${String(said.length)} thing(s)`
-  const one = spliced(said[0] ?? '', shape.names, shape.mine, ROLES.block)
+  const one = spliced(said[0] ?? '', shape, ROLES.block)
   if (typeof one === 'string') return one
 
-  if (!ends) return { runs: answered(name, one, opened, 'const') }
+  const unread = shape.unread.has(name)
+  if (!ends) return { runs: answered(name, one, opened, 'const', unread) }
 
   return {
     runs: [
-      ...answered(name, one, opened, 'const'),
+      ...answered(name, one, opened, 'const', unread),
       `throw Object.assign(new Error(${quoted(`${name} ended the operation`)}), { [${STOPS}]: true, value: ${name} })`,
     ],
   }
@@ -447,6 +453,7 @@ function compiled(
   id: string,
   one: ReturnType<typeof operations> extends ReadonlyMap<string, infer W> ? W : never,
   known: ReadonlySet<string>,
+  unread?: ReadonlySet<string>,
 ): { readonly text?: string; readonly because?: string } {
   const because = problem(id, one)
   if (because !== undefined) return { because }
@@ -474,6 +481,7 @@ function compiled(
 
   const runs: string[] = []
   const names = new Set<string>()
+  const heard = new Set<string>()
   let last: string | undefined
 
   for (const [order, row] of one.nodes.entries()) {
@@ -500,7 +508,7 @@ function compiled(
       return { because: `the node \`${name}\` states no block this can read in ${row.at} — run \`thread seed\` and write it again` }
     }
 
-    const shape: Shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine }
+    const shape: Shape = { all: `Opened<${only}>`, reads: `Reads<Opened<${only}>>`, names, mine, heard, unread: unread ?? new Set<string>() }
     const made = (SHAPES[from] ?? ownType)(name, parts(held), shape)
     if (typeof made === 'string') return { because: `the node \`${name}\` ${made}` }
 
@@ -510,12 +518,19 @@ function compiled(
     last = from === 'nd_stop' ? undefined : name
   }
 
+  if (unread === undefined) {
+    const final = one.nodes.at(-1)?.id
+    return compiled(at, id, one, known, new Set([...mine].filter((name) => name !== final && !heard.has(name))))
+  }
+
+  const typed = ['Opened', 'Reads'].filter((word) => runs.some((line) => line.includes(`${word}<`)))
+
   return {
     text: [
       "import type { z } from 'zod'",
       '',
       `import type { Operation } from ${quoted(runtime(at, '../operations.ts'))}`,
-      'import type { Opened, Reads } from ' + quoted(runtime(at, '../operations.ts')),
+      ...(typed.length === 0 ? [] : [`import type { ${typed.join(', ')} } from ${quoted(runtime(at, '../operations.ts'))}`]),
       '',
       `import { input, resource } from ${quoted(beside(at, takes))}`,
       '',
@@ -530,7 +545,7 @@ function compiled(
       ...(quota === undefined ? [] : [`  quota: ${quota},`]),
       '',
       '  run: async (opened, held) => {',
-      '    const input = held.input',
+      ...(unread.has('input') ? [] : ['    const input = held.input']),
       `    let ${ENTERED} = ''`,
       '    try {',
       ...runs,

package/dist/operations/generators/permits.js

@@ -61,6 +61,7 @@ if (open.length > 0) {
         'that decision in the sheet. Otherwise name the roles that may, or state a `when` saying whose row it is');
 }
 const said = (held) => JSON.stringify(held);
+const used = new Set();
 function reads(one, grant) {
     if ('value' in one)
         return said(one.value);
@@ -85,6 +86,7 @@ function reads(one, grant) {
                 grant.on +
                 '" itself, or state the rule as an invariant where the rows are');
         }
+        used.add(READS);
         return `at(resource, ${said(one.field)})`;
     }
     stop(`\`${grant.id}\` states an operand this gate cannot read`);
@@ -98,6 +100,7 @@ function predicate(condition, grant) {
     }
     if ('not' in condition)
         return `(!${predicate(condition.not, grant)})`;
+    used.add(COMPARES);
     return `held(${said(condition.op)}, ${reads(condition.is, grant)}, ${reads(condition.than, grant)})`;
 }
 function wears(grant) {
@@ -107,6 +110,8 @@ function wears(grant) {
         held.push(`some(actor.roles, ${said(roles)})`);
     if (grant.to?.entitlements !== undefined)
         held.push(`some(actor.entitlements, ${said(grant.to.entitlements)})`);
+    if (held.length > 0)
+        used.add(WEARS);
     return held;
 }
 const READS = ['const at = (row: Row | null, name: string): unknown => (row === null ? undefined : row[name])'];
@@ -154,9 +159,7 @@ function permitting() {
         `import type { Actor } from '${runtime(PERMITS_AT, '../../core/actor.ts')}'`,
         "import type { Row } from '" + runtime(PERMITS_AT, '../../integrations/target.ts') + "'",
         '',
-        ...(grants.some((one) => one.when !== undefined) ? [...READS, ''] : []),
-        ...(grants.some((one) => one.to !== undefined) ? [...WEARS, ''] : []),
-        ...(grants.some((one) => one.when !== undefined) ? [...COMPARES, ''] : []),
+        ...[READS, WEARS, COMPARES].filter((one) => used.has(one)).flatMap((one) => [...one, '']),
         'export function permits(actor: Actor, action: string, resource: Row | null): { allow: boolean; because?: string } {',
         ...(grants.length === 0 ? ['  void actor', '  void resource'] : []),
         ...body,

package/dist/operations/generators/permits.ts

@@ -1,8 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
 import { valuesIn } from '../../core/rows.ts'
-import { dirname, resolve } from 'node:path'
+import { resolve } from 'node:path'
 import { argv, stderr, stdout } from 'node:process'
-import { pathToFileURL } from 'node:url'
 
 import { exit } from '../../core/invoked.ts'
 import { PUBLIC_ROLE as PUBLIC } from '../../core/actor.ts'
@@ -81,6 +80,8 @@ if (open.length > 0) {
 
 const said = (held: unknown): string => JSON.stringify(held)
 
+const used = new Set<readonly string[]>()
+
 function reads(one: Operand, grant: Grant): string {
   if ('value' in one) return said(one.value)
   if ('now' in one) return 'Date.now()'
@@ -106,6 +107,7 @@ function reads(one: Operand, grant: Grant): string {
           '" itself, or state the rule as an invariant where the rows are',
       )
     }
+    used.add(READS)
     return `at(resource, ${said(one.field)})`
   }
   stop(`\`${grant.id}\` states an operand this gate cannot read`)
@@ -119,6 +121,7 @@ function predicate(condition: Condition, grant: Grant): string {
     return condition.any.length === 0 ? 'false' : `(${condition.any.map((one) => predicate(one, grant)).join(' || ')})`
   }
   if ('not' in condition) return `(!${predicate(condition.not, grant)})`
+  used.add(COMPARES)
   return `held(${said(condition.op)}, ${reads(condition.is, grant)}, ${reads(condition.than, grant)})`
 }
 
@@ -127,6 +130,7 @@ function wears(grant: Grant): readonly string[] {
   const roles = grant.to?.roles
   if (roles !== undefined && !roles.includes(PUBLIC)) held.push(`some(actor.roles, ${said(roles)})`)
   if (grant.to?.entitlements !== undefined) held.push(`some(actor.entitlements, ${said(grant.to.entitlements)})`)
+  if (held.length > 0) used.add(WEARS)
   return held
 }
 
@@ -181,9 +185,7 @@ function permitting(): string {
     `import type { Actor } from '${runtime(PERMITS_AT, '../../core/actor.ts')}'`,
     "import type { Row } from '" + runtime(PERMITS_AT, '../../integrations/target.ts') + "'",
     '',
-    ...(grants.some((one) => one.when !== undefined) ? [...READS, ''] : []),
-    ...(grants.some((one) => one.to !== undefined) ? [...WEARS, ''] : []),
-    ...(grants.some((one) => one.when !== undefined) ? [...COMPARES, ''] : []),
+    ...[READS, WEARS, COMPARES].filter((one) => used.has(one)).flatMap((one) => [...one, '']),
 
     'export function permits(actor: Actor, action: string, resource: Row | null): { allow: boolean; because?: string } {',
     ...(grants.length === 0 ? ['  void actor', '  void resource'] : []),

package/dist/operations/generators/trial.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, writeFileSync, type Answering, type Listed } from '../../integrations/disk.ts'
-import { dirname, resolve } from 'node:path'
+import { resolve } from 'node:path'
 import { argv, stdout } from 'node:process'
 import { pathToFileURL } from 'node:url'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prestack/thread",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "files": [
     "dist",