@prestack/thread 0.1.20 → 0.1.22

package/dist/integrity/slopnators/sl_undeclared_variant.ts

@@ -1,152 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-import { descend, read, reached } from '../../core/descend.ts'
-
-import { rowsIn } from './sl_unthreaded.ts'
-
-const ELEMENT = 'element'
-
-const VARIANT = 'variant'
-
-interface Worn {
-  readonly elements: ReadonlySet<string>
-  readonly variants: ReadonlyMap<string, readonly string[]>
-}
-
-function nameOf(id: string): string {
-  return id
-    .split('-')
-    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
-    .join('')
-}
-
-function idOf(name: string): string {
-  return name.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
-}
-
-function memberOf(id: string): string {
-  const [first = '', ...rest] = id.split('-')
-  return first + rest.map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join('')
-}
-
-function declared(): Worn {
-  const elements = new Set<string>()
-  const variants = new Map<string, readonly string[]>()
-
-  descend()
-
-  for (const at of reached()) {
-    const text = read(at)
-    if (text === undefined) continue
-
-    let waiting: { readonly id: string; readonly wears?: readonly string[] }[] = []
-    for (const one of rowsIn(text)) {
-      if (one.id === undefined) continue
-      if (one.list === 'declares') {
-        waiting.push(one.wears === undefined ? { id: one.id } : { id: one.id, wears: one.wears })
-        continue
-      }
-      if (one.list !== undefined) continue
-      if (one.id === ELEMENT) for (const row of waiting) elements.add(nameOf(row.id))
-      if (one.id === VARIANT) for (const row of waiting) variants.set(row.id, row.wears ?? [])
-      waiting = []
-    }
-  }
-
-  return { elements, variants }
-}
-
-interface Tag {
-  readonly type?: string
-  readonly object?: { readonly type?: string; readonly name?: string }
-  readonly property?: { readonly type?: string; readonly name?: string }
-}
-
-export const slopnator: Slopnator = {
-  on: ['JSXOpeningElement'],
-  holds: (node) => {
-    const name = (node as { name?: Tag } | undefined)?.name
-    if (name?.type !== 'JSXMemberExpression') return false
-
-    const element = name.object?.type === 'JSXIdentifier' ? name.object.name : undefined
-    const member = name.property?.type === 'JSXIdentifier' ? name.property.name : undefined
-    if (element === undefined || member === undefined) return false
-
-    const { elements, variants } = declared()
-    if (!elements.has(element)) return false
-
-    const id = idOf(member)
-    const wears = variants.get(id)
-
-    const worn = [...variants]
-      .filter(([, all]) => all.includes(element))
-      .map(([one]) => `${element}.${memberOf(one)}`)
-      .sort()
-
-    const offered =
-      worn.length === 0
-        ? `nothing declares itself worn by \`${element}\`, so no member of it would have been accepted — a variant row has to name \`${element}\` first`
-        : `\`${element}\` wears ${worn.join(', ')}`
-
-    if (wears === undefined) {
-      return (
-        `\`${element}.${member}\` names the variant \`${id}\` and nothing declares it — so it renders carrying a class ` +
-        'the stylesheet never writes, which reads on screen as an element that lost its styling and is reported ' +
-        `nowhere. ${offered}`
-      )
-    }
-
-    if (!wears.includes(element)) {
-      return (
-        `\`${element}.${member}\` pairs \`${element}\` with the variant \`${id}\`, and that variant's row does not name ` +
-        `\`${element}\` among the elements that wear it — so the pairing is nobody's declaration. ${offered}`
-      )
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_worn.ts',\n    },\n  ],\n}\n" },
-          {
-            at: 'threads/_probe_worn.ts',
-            source:
-              "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const ELEMENTS: Threaded = {\n  id: 'element',\n  declares: [\n    {\n      id: 'button',\n      at: 'app/_probe_button.tsx',\n    },\n  ],\n}\n\nexport const VARIANTS: Threaded = {\n  id: 'variant',\n  declares: [\n    {\n      id: 'button-primary',\n      at: 'app/_probe_variant.ts',\n      wears: ['Button'],\n    },\n  ],\n}\n",
-          },
-          { at: 'app/_probe_undeclared.tsx', source: 'export const HELD = <Button.primary />\n' },
-        ],
-        at: 'app/_probe_undeclared.tsx',
-      },
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_worn.ts',\n    },\n  ],\n}\n" },
-          {
-            at: 'threads/_probe_worn.ts',
-            source:
-              "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const ELEMENTS: Threaded = {\n  id: 'element',\n  declares: [\n    {\n      id: 'button',\n      at: 'app/_probe_button.tsx',\n    },\n    {\n      id: 'badge',\n      at: 'app/_probe_badge.tsx',\n    },\n  ],\n}\n\nexport const VARIANTS: Threaded = {\n  id: 'variant',\n  declares: [\n    {\n      id: 'chip',\n      at: 'app/_probe_chip.ts',\n      wears: ['Badge'],\n    },\n  ],\n}\n",
-          },
-          { at: 'app/_probe_mispaired.tsx', source: 'export const HELD = <Button.chip />\n' },
-        ],
-        at: 'app/_probe_mispaired.tsx',
-      },
-    ],
-    right: [
-      {
-        files: [
-          {
-            at: 'threads/_probe_worn.ts',
-            source:
-              "export const ELEMENTS: Threaded = {\n  id: 'element',\n  declares: [\n    {\n      id: 'button',\n      at: 'app/_probe_button.tsx',\n    },\n  ],\n}\n\nexport const VARIANTS: Threaded = {\n  id: 'variant',\n  declares: [\n    {\n      id: 'button-primary',\n      at: 'app/_probe_variant.ts',\n      wears: ['Button'],\n    },\n  ],\n}\n",
-          },
-          { at: 'app/_probe_declared.tsx', source: 'export const HELD = <Button.buttonPrimary />\n' },
-        ],
-        at: 'app/_probe_declared.tsx',
-      },
-      '<Unknown.anything />',
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_undeclared_webhook.ts

@@ -1,108 +0,0 @@
-import ts from 'typescript'
-
-import { descend } from '../../core/descend.ts'
-
-import type { Slopnator } from '../slopnator.ts'
-
-const said = (held: ts.Expression | undefined): string | undefined =>
-  held !== undefined && ts.isStringLiteral(held) ? held.text : undefined
-
-const listed = (held: ts.Expression | undefined): readonly string[] =>
-  held !== undefined && ts.isArrayLiteralExpression(held)
-    ? held.elements.filter((one) => ts.isStringLiteral(one)).map((one) => (one as ts.StringLiteral).text)
-    : []
-
-const yes = (held: ts.Expression | undefined): boolean =>
-  held !== undefined && held.kind === ts.SyntaxKind.TrueKeyword
-
-interface Asking {
-  readonly id: string
-  readonly invokes: string
-  readonly carries: boolean
-}
-
-function invoking(text: string): { readonly asking: readonly Asking[]; readonly rows: ReadonlyMap<string, ts.ObjectLiteralExpression> } {
-  const file = ts.createSourceFile('row.ts', text, ts.ScriptTarget.Latest, true)
-  const rows = new Map<string, ts.ObjectLiteralExpression>()
-  const found: Asking[] = []
-  const visit = (node: ts.Node): void => {
-    if (ts.isObjectLiteralExpression(node)) {
-      const of = (name: string): ts.Expression | undefined => {
-        for (const one of node.properties) {
-          if (ts.isPropertyAssignment(one) && ts.isIdentifier(one.name) && one.name.text === name) return one.initializer
-        }
-        return undefined
-      }
-      const id = said(of('id'))
-      if (id !== undefined) rows.set(id, node)
-      const invokes = said(of('invokes'))
-      if (id !== undefined && invokes !== undefined) {
-        found.push({ id, invokes, carries: said(of('arrives')) !== undefined && listed(of('requires')).length > 0 })
-      }
-    }
-    ts.forEachChild(node, visit)
-  }
-  visit(file)
-  return { asking: found, rows }
-}
-
-const fieldOf = (node: ts.ObjectLiteralExpression, name: string): ts.Expression | undefined => {
-  for (const one of node.properties) {
-    if (ts.isPropertyAssignment(one) && ts.isIdentifier(one.name) && one.name.text === name) return one.initializer
-  }
-  return undefined
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const { asking, rows } = invoking(at.text)
-    if (asking.length === 0) return false
-    const found: string[] = []
-    const pass = descend()
-    for (const one of asking) {
-      const here = rows.get(one.invokes)
-      const named = here === undefined ? undefined : listed(fieldOf(here, 'webhooks'))
-      const signs = here === undefined ? undefined : yes(fieldOf(here, 'signed'))
-      const runs = pass.stated.get(one.invokes)
-      if (here === undefined && runs === undefined) {
-        found.push(one.id + ' invokes ' + one.invokes + ', and nothing in this tree declares an operation by that name')
-        continue
-      }
-      if (!(named ?? listed(runs?.fields.get('webhooks'))).includes(one.id)) {
-        found.push(
-          one.id + ' invokes ' + one.invokes + ', and that operation names no webhook ' + one.id +
-            ' back, so it is reachable from outside by something it never agreed to',
-        )
-      }
-      if ((signs ?? yes(runs?.fields.get('signed'))) && !one.carries) {
-        found.push(
-          one.invokes + ' takes only a signed webhook, and ' + one.id +
-            ' states no header a signature arrives on and no secret to check it against',
-        )
-      }
-    }
-    return found.length === 0 ? false : found.join('; ')
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly invokes?: string\n  readonly webhooks?: readonly string[]\n  readonly declares?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    { at: 'threads/_probe_webhook.ts' },\n  ],\n}\n" },
-          { at: 'threads/_probe_webhook.ts', source: "export const WEBHOOKS: Threaded = {\n  id: 'webhooks',\n  declares: [\n    { id: 'wh_stripe', at: 'app/inbound/wh_stripe/route.ts', invokes: 'wf_charge' },\n    { id: 'wf_charge', at: 'operations/wf_charge.ts' },\n  ],\n}\n" },
-        ],
-        at: 'threads/_probe_webhook.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly version?: number\n  readonly invokes?: string\n  readonly webhooks?: readonly string[]\n  readonly by?: string\n  readonly runs?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    { at: 'threads/_probe_webhook.ts' },\n  ],\n}\n" },
-          { at: 'threads/_probe_webhook.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const WEBHOOKS: Threaded = {\n  id: 'webhooks',\n  version: 1,\n  declares: [\n    { id: 'wf_charge', at: 'operations/wf_charge.ts', webhooks: ['wh_stripe'] },\n  ],\n  derives: [\n    { id: 'wh_stripe', at: 'app/inbound/wh_stripe/route.ts', invokes: 'wf_charge', by: 'thread capabilities', runs: 'thread capabilities --check' },\n  ],\n}\n" },
-        ],
-        at: 'threads/_probe_webhook.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_underived_route.ts

@@ -1,72 +0,0 @@
-import ts from 'typescript'
-
-import { LISTS as LINEAGE } from '../../core/descend.ts'
-
-import type { Slopnator } from '../slopnator.ts'
-
-const LISTS: ReadonlySet<string> = new Set(LINEAGE)
-
-const ROUTE = '/route.ts'
-
-const said = (held: ts.Expression | undefined): string | undefined =>
-  held !== undefined && ts.isStringLiteral(held) ? held.text : undefined
-
-const fieldOf = (node: ts.ObjectLiteralExpression, name: string): ts.Expression | undefined => {
-  for (const one of node.properties) {
-    if (ts.isPropertyAssignment(one) && ts.isIdentifier(one.name) && one.name.text === name) return one.initializer
-  }
-  return undefined
-}
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const file = ts.createSourceFile('row.ts', at.text, ts.ScriptTarget.Latest, true)
-    const routes = new Map<string, string>()
-    const permitted = new Set<string>()
-
-    const visit = (node: ts.Node): void => {
-      if (
-        ts.isPropertyAssignment(node) &&
-        ts.isIdentifier(node.name) &&
-        LISTS.has(node.name.text) &&
-        ts.isArrayLiteralExpression(node.initializer)
-      ) {
-        const list = node.name.text
-        for (const one of node.initializer.elements) {
-          if (!ts.isObjectLiteralExpression(one)) continue
-          const where = said(fieldOf(one, 'at'))
-          if (where === undefined || !where.endsWith(ROUTE)) continue
-          routes.set(where, list)
-          if (list === 'derives' && said(fieldOf(one, 'by')) !== undefined && said(fieldOf(one, 'runs')) !== undefined) {
-            permitted.add(where)
-          }
-        }
-      }
-      ts.forEachChild(node, visit)
-    }
-    visit(file)
-
-    const found: string[] = []
-    for (const [where, list] of routes) {
-      if (permitted.has(where)) continue
-      found.push(
-        where + ' is named by a ' + list + ' row' +
-          (list === 'derives' ? ' that states no by and no runs' : '') +
-          ', and a route is only ever derived',
-      )
-    }
-    return found.length === 0 ? false : found.join('; ')
-  },
-  proves: {
-    wrong: ["const M = { seeds: [{ at: 'app/inbound/wh_stripe/route.ts' }] }"],
-    right: [
-      {
-        files: [
-          { at: 'threads/thread.ts', source: "export const THREAD = {\n  declares: [\n    { at: 'threads/_probe_route.ts' },\n  ],\n}\n" },
-          { at: 'threads/_probe_route.ts', source: "export const M = {\n  derives: [\n    { at: 'app/inbound/wh_stripe/route.ts', by: 'thread capabilities', runs: 'thread capabilities --check' },\n  ],\n}\n" },
-        ],
-        at: 'threads/_probe_route.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_undescribed.ts

@@ -1,65 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-
-const COMMON = new Set([
-  'a', 'an', 'the', 'of', 'for', 'to', 'and', 'or', 'is', 'it', 'its', 'this', 'that',
-  'in', 'on', 'at', 'as', 'by', 'with', 'be', 'are', 'was', 'one', 'every', 'each',
-])
-
-type Node = {
-  type?: string
-  name?: string
-  key?: { type?: string; name?: string; value?: unknown }
-  value?: { type?: string; value?: unknown }
-  computed?: boolean
-  properties?: readonly Node[]
-}
-
-const keyOf = (property: Node): string | undefined => {
-  if (property.computed === true) return undefined
-  const key = property.key
-  if (key?.type === 'Identifier') return key.name
-  if (key?.type === 'Literal' && typeof key.value === 'string') return key.value
-  return undefined
-}
-
-const said = (property: Node | undefined): string | undefined => {
-  const held = property?.value
-  return held?.type === 'Literal' && typeof held.value === 'string' ? held.value : undefined
-}
-
-const words = (text: string): readonly string[] =>
-  text.toLowerCase().split(/[^a-z]+/).filter((one) => one !== '' && !COMMON.has(one))
-
-export const slopnator: Slopnator = {
-  on: ['Property'],
-  holds: (node, at) => {
-    const property = node as Node
-    const key = keyOf(property)
-    if (key !== 'describes' && key !== 'means') return false
-
-    const sentence = said(property)
-    if (sentence === undefined) return false
-    if (sentence.trim() === '') return `\`${key}\` is empty, so the word arrived and the meaning never did`
-
-    const owner = (at.ancestors() as readonly Node[]).at(-1)
-    const id = said((owner?.properties ?? []).find((one) => keyOf(one) === 'id' || keyOf(one) === 'name'))
-    if (id === undefined) return false
-
-    const own = new Set(words(id))
-    if (words(sentence).some((word) => !own.has(word))) return false
-    return `\`${key}\` says "${sentence}", which adds no word its id \`${id}\` does not already carry`
-  },
-  proves: {
-    wrong: [
-      "const M = { id: 'law', describes: 'The law.' }",
-      "const M = { id: 'law', describes: '' }",
-      "const M = { id: 'term', means: '' }",
-      "const M = { id: 'thread-check', describes: 'The thread check.' }",
-    ],
-    right: [
-      "const M = { id: 'law', describes: 'A rule that must be guaranteed to be enforced.' }",
-      "const M = { id: 'term', means: 'A word this repository coins, and what somebody reading it should understand.' }",
-      "const M = { id: 'law', at: 'packages/core/integrity/src/constraint.ts' }",
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_ungoverned_island.ts

@@ -1,60 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-import { here, islandsDeclared } from './sl_unthreaded.ts'
-import { findTree } from '../../core/tree.ts'
-
-const TREE = `${findTree().name}/`
-const GOVERNS = /^\s*governs:\s*'([^']+)'/gm
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-    if (!path.startsWith(TREE)) return false
-
-    let islands: readonly string[]
-    try {
-      islands = islandsDeclared().map((one) => one.id)
-    } catch {
-      return 'this file cannot be parsed, so the islands the tree declares were never read and nothing a law threaded to govern was measured'
-    }
-
-    for (const match of at.text.matchAll(GOVERNS)) {
-      const governed = match[1] ?? ''
-      if (islands.includes(governed)) continue
-      return `a law governs "${governed}" and the tree declares no island by that name, so the rule reads as coverage of a kind nobody can declare`
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          {
-            at: 'threads/_governed_probe.ts',
-            source: "export const L: Constraint = {\n  id: 'a-law',\n  governs: 'no-island-by-this-name',\n}\n",
-          },
-        ],
-        at: 'threads/_governed_probe.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'threads/thread.ts', source: "export const THREAD: Threaded = {\n  declares: [\n    { id: 'entities', at: 'src/islands/entities.ts', governs: ['app/_declare/entities.ts'] },\n  ],\n}\n" },
-          { at: 'src/islands/entities.ts', source: 'export const EntitiesIslandSchema = {}\nexport function defineEntities() {}\n' },
-          { at: 'threads/_governed_probe.ts', source: "export const L: Constraint = {\n  id: 'a-law',\n  governs: 'entities',\n}\n" },
-        ],
-        at: 'threads/_governed_probe.ts',
-      },
-      {
-        files: [
-          {
-            at: 'threads/_governed_probe.ts',
-            source: "export const M: Islanding = {\n  declares: [\n    { id: 'events', at: 'packages/core/spec/src/islands/events.ts', governs: ['operations/'] },\n  ],\n}\n",
-          },
-        ],
-        at: 'threads/_governed_probe.ts',
-      },
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_unlisted_program.ts

@@ -1,46 +0,0 @@
-import { ROOT } from '../../core/descend.ts'
-import { valuesIn } from '../../core/rows.ts'
-import { kind } from '../../integrations/disk.ts'
-import { REACH, programOf, unlisted } from '../../integrations/target.ts'
-
-import type { Slopnator } from '../slopnator.ts'
-
-const TARGETS = 'TARGETS'
-
-const there = (path: string): boolean => kind(path) === 'file'
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    let held: { readonly TARGETS?: readonly { readonly id?: unknown }[] }
-    try {
-      held = valuesIn(at.text) as { readonly TARGETS?: readonly { readonly id?: unknown }[] }
-    } catch (thrown) {
-      if (!at.text.includes(TARGETS)) return false
-      return 'this sheet names ' + TARGETS + ' and could not be read as values, so no target on it was checked — ' + (thrown instanceof Error ? thrown.message : String(thrown))
-    }
-    const found: string[] = []
-    for (const one of held.TARGETS ?? []) {
-      if (typeof one.id !== 'string' || !one.id.startsWith(REACH.cli)) continue
-      const name = one.id.slice(REACH.cli.length)
-      if (programOf(name, ROOT, there) === undefined) found.push(unlisted(name))
-    }
-    return found.length === 0 ? false : found.join('. ')
-  },
-  proves: {
-    wrong: [
-      "export const TARGETS: readonly Target[] = [{ id: 'cli_bash', of: 'in_shell', describes: 'The shell on the machine a command runs on.', version: 1, takes: [], requires: [] }]",
-    ],
-    right: [
-      {
-        files: [
-          { at: 'node_modules/.bin/tsc', source: '' },
-          { at: 'threads/_probe_targets.ts', source: "export const TARGETS: readonly Target[] = [{ id: 'cli_tsc', of: 'in_typescript', describes: 'The compiler this tree is checked and built with.', version: 1, takes: [], requires: [] }]\n" },
-        ],
-        at: 'threads/_probe_targets.ts',
-      },
-      "export const TARGETS: readonly Target[] = [{ id: 'cli_packager', of: 'in_packager', describes: 'The package manager the lockfile beside this tree picks.', version: 1, takes: [], requires: [] }]",
-      "export const TARGETS: readonly Target[] = [{ id: 'cli_node', of: 'in_node', describes: 'The runtime this framework runs on.', version: 1, takes: [], requires: [] }]",
-      "export const TARGETS: readonly Target[] = [{ id: 'ht_registry', of: 'in_registry', describes: 'The registry every package goes to.', version: 1, takes: [], requires: [], address: 'https://registry.npmjs.org' }]",
-    ],
-  },
-}

package/dist/integrity/slopnators/sl_unnamed_island.ts

@@ -1,41 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-import { declaresIsland, here, islandsDeclared } from './sl_unthreaded.ts'
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const schema = declaresIsland(at.text)
-    if (schema === undefined) return false
-
-    const path = here(at.filename)
-    if (islandsDeclared().some((island) => island.at === path)) return false
-
-    return (
-      `${schema}IslandSchema is an island and no row in the tree names it, so nothing states what it governs and ` +
-      'no law can reach it — the kind is declarable and every rule about where it may be declared is absent'
-    )
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          {
-            at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
-            source: 'export const ThingIslandSchema = z.strictObject({\n  specVersion: z.literal(1),\n})\n',
-          },
-        ],
-        at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          {
-            at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
-            source: 'export const ThingSchema = z.strictObject({\n  name: z.string(),\n})\n',
-          },
-        ],
-        at: 'packages/core/spec/src/islands/_unnamed_probe.ts',
-      },
-    ],
-  },
-}