ae35005 · jibb · git.iko.soy

git.iko.soy/jibb

Import source-verified tagged Hoon unions

commitae35005617f0cf4abada773e5225effaafa09ea4 authoriko <mail@iko.soy> dateSat 31 Oct 2026, 01:13 (12 hours ago) parentd69cc52

8 files changed+307−8

compare with master

unifiedsplit

docs/compiler.md+1−1 docs/status.md+4−3 jibb-dev/lib/jibb-import.hoon+246−2 tests/importer/about.txt+5−1 tests/importer/shadow-static.txt+4 tests/importer/small.txt+26 tests/importer/tree.txt+20 tools/importer-test+1−1

docs/compiler.md+1−1

@@ -80,7 +80,7 @@ A known closed union with two or more arms can be matched when each arm provably

8080

8181A known closed union can also provide context to each arm of a complete loobean or unit-shaped branch in a cast or a call with a known union sample. Nested branches and transparent groups work; a mismatch reports the expected union and the offending arm. General patterns and context through bodies with local definitions remain unsupported, and unrelated unresolved tags stay pending.

8282

83−The separate `jibb-dev/lib/jibb-import.hoon` is an unfinished reader for selected Hoon type graphs. It handles named recursion, nested map, set, queue, list, unit, jar and jug arguments, direct ordered maps, and direct `$^` unions whose source branches can be proved disjoint. It also reads ordered map fields in records when the map arguments are syntactically fixed atom molds and other fields are fixed atom molds or standard collections of static atom molds. Collection names must not be shadowed. The reader can also import a mark door sample, removing its outer sample face and validating its build subject. The reader checks explicit Hoon `$%`, `$?` and `$^` unions against the Grammar’s disjointness rule, as @iko confirmed on 2026-10-30. It re-evaluates statically recognizable source branches before Hoon can collapse them, checks materialized fork cases, and rejects shapes it cannot prove disjoint. Static records may also have verified standard-collection and `path` siblings. One direct explicit union argument in a standard list, set, map or unit is accepted when its call wrapper and collection provenance are verified and its static cases are pairwise disjoint. A synthetic regression checks that forged wrapper subjects, samples and tails are rejected. Other collection-union forms, nested ordered maps, general source-level disjointness and complete integration with the checker remain unfinished. `+golden-types-imports` can consume fixed-aura atoms, valid term singletons, nested faced or unfaced cells, unions of supported, pairwise-disjoint cases, and opaque standard collections with supported arguments from caller-supplied reader results for declared `/-` imports; `+golden-types-with-marks` accepts the same shapes for declared marks. The caller must pass unchanged results from the source-aware reader: the bridge validates the supplied graph but cannot detect source cases Hoon collapsed before that graph was built. The opaque collection types retain their names and arguments for identity, unification and printing. The validated standard prelude `list` mold shares the imported list representation; other Jibb-written collection molds and most prelude collection operations remain unsupported. Other forms remain unsupported. Its disjointness proof is conservative and can reject a valid union it cannot prove disjoint. Collection recognition requires the originating `/sur` core. The reader validates direct zuse subjects and Ford subjects consisting of faced imported cores and a validated tail, checking imported cores transitively; it rejects shadowed names, inconsistent core subjects and other subject shapes. For a recursive reference, the reader matches the exact Hoon hold against named arms in validated cores, including transitive Ford imports; it rejects missing, unlabelled or ambiguous origins. Its fixtures include three real Tlon files; `tools/importer-test` compares the internal projection under eval, and the ship test compares the same golden output. `tools/type-import-test` and `tools/type-mark-test` compare bridge reports under eval and on the ship. `tools/clay-fixtures` also passes Clay-built `/sur` molds and mark samples through the Clay-built importer and partial checker.

83+The separate `jibb-dev/lib/jibb-import.hoon` is an unfinished reader for selected Hoon type graphs. It handles named recursion, nested map, set, queue, list, unit, jar and jug arguments, direct ordered maps, and direct `$^` unions whose source branches can be proved disjoint. It also reads ordered map fields in records when the map arguments are syntactically fixed atom molds and other fields are fixed atom molds or standard collections of static atom molds. Collection names must not be shadowed. The reader can also import a mark door sample, removing its outer sample face and validating its build subject. The reader checks explicit Hoon `$%`, `$?` and `$^` unions against the Grammar’s disjointness rule, as @iko confirmed on 2026-10-30. For an explicit `$%` with distinct literal head tags, it can also prove restricted local named payload dependencies, re-evaluate and validate each source branch, and recover the union before Hoon collapses it. It rejects recursive or computed dependencies, inherited same-name collisions, unsupported nested unions and proofs exceeding a shared 4,096-node budget. It re-evaluates statically recognizable source branches before Hoon can collapse them, checks materialized fork cases, and rejects shapes it cannot prove disjoint. Static records may also have verified standard-collection and `path` siblings. One direct explicit union argument in a standard list, set, map or unit is accepted when its call wrapper and collection provenance are verified and its static cases are pairwise disjoint. A synthetic regression checks that forged wrapper subjects, samples and tails are rejected. Other collection-union forms, nested ordered maps, general source-level disjointness and complete integration with the checker remain unfinished. `+golden-types-imports` can consume fixed-aura atoms, valid term singletons, nested faced or unfaced cells, unions of supported, pairwise-disjoint cases, and opaque standard collections with supported arguments from caller-supplied reader results for declared `/-` imports; `+golden-types-with-marks` accepts the same shapes for declared marks. The caller must pass unchanged results from the source-aware reader: the bridge validates the supplied graph but cannot detect source cases Hoon collapsed before that graph was built. The opaque collection types retain their names and arguments for identity, unification and printing. The validated standard prelude `list` mold shares the imported list representation; other Jibb-written collection molds and most prelude collection operations remain unsupported. Other forms remain unsupported. Its disjointness proof is conservative and can reject a valid union it cannot prove disjoint. Collection recognition requires the originating `/sur` core. The reader validates direct zuse subjects and Ford subjects consisting of faced imported cores and a validated tail, checking imported cores transitively; it rejects shadowed names, inconsistent core subjects and other subject shapes. For a recursive reference, the reader matches the exact Hoon hold against named arms in validated cores, including transitive Ford imports; it rejects missing, unlabelled or ambiguous origins. Its fixtures include three real Tlon files; `tools/importer-test` compares the internal projection under eval, and the ship test compares the same golden output. `tools/type-import-test` and `tools/type-mark-test` compare bridge reports under eval and on the ship. `tools/clay-fixtures` also passes Clay-built `/sur` molds and mark samples through the Clay-built importer and partial checker.

8484

8585Self-recursive `/sur` molds can cross the bridge as opaque module-and-name identities when their supported source-aware graph passes validation. Aliases, foreign references, recursive marks, unfolding, construction and field access remain unsupported; the partial printer declines recursive names that are not in scope.

8686

docs/status.md+4−3

@@ -19,7 +19,7 @@ On 2026-10-30, @iko decided that Jibb drops `$?`, so a `+$` takes a union's case

1919

2020## Milestone 2: in progress

2121

22−The repository spec records the subsequent type-system and prelude decisions; those changes also need synchronization to the Claude document. An initial inference fragment and a standalone Hoon type reader are being tested. The fragment explicitly reports that it does not check a module; partial bridges pass selected Hoon atoms, term singletons, nested faced or unfaced cells, supported disjoint unions and opaque standard collections from `/sur` molds and marks into inference. Collections retain their names and supported arguments for printing and unification; nested supported union arguments are retained too. The bridge trusts unchanged results from the source-aware reader; a materialized type graph alone cannot reveal cases Hoon already collapsed. The source-validated standard prelude `list` mold shares this representation with imported lists; other Jibb-written collection molds and most prelude collection operations remain unsupported; malformed names and arities fail closed. Selected self-recursive `/sur` molds cross as opaque module-and-name identities; aliases, foreign references, recursive marks, unfolding and construction remain unsupported. The reader handles mark samples, recursive molds whose origins can be verified through Ford imports, nested collections, direct ordered maps, certain ordered-map fields, direct `$^` unions whose cases can be proved disjoint, and one verified explicit union argument in a list, set, map or unit. Ambiguous recursive origins fail closed; recognizable explicit unions are checked from source before Hoon can collapse their cases, as @iko confirmed for imported `$%`, `$?` and `$^`, while other nested unions, nested ordered maps, general union disjointness and complete import integration remain unfinished. Opt-in structured reader APIs preserve successful graphs and distinguish definite unsupported-aura and core evidence from failures the reader cannot prove; unverified union disjointness and name-only vase recognition remain unsupported. They revalidate and re-walk failed types. An opt-in partial checker entry point consumes unchanged reader results and reports definite aura or core errors at imported mold use sites when their inputs are unique. Ordered replay covers nested cell samples, record and function casts, and non-generic same-module aliases; unsupported prefixes, cycles and shadowing stop it. Union molds, generic applications, transitive modules and unsupported reader outcomes remain generic. Replay repeats inference and may add work. The partial checker resolves a subset of ordinary library imports in dependency order using supplied Jibb sources and a source-derived partial prelude interface, caches completed interfaces per run, and detects missing sources and cycles. It does not yet check API or kind semantics, and the prelude inventory is incomplete. The inference fragment supports unrestricted `@`, selected one-way widenings including aura-family ancestors, generalized atom constraints arising from explicit capitals or bare sample binders, acyclic local value definitions with captures, selected single self-recursive top-level and local gates, simple and nonrecursive generic mold aliases, selected faced record casts and field reads, and contextual tags, `~` and constructors for closed disjoint unions, including direct nonrecursive generic unions and propagation through complete loobean and unit-shaped branches in casts and known union-sample calls, including nested branches. Multi-argument calls form a right-nested sample, retain known faces and shared type variables, and can use known sample positions to contextualize list and union arguments. A definite mismatch points to the failing argument when the fragment can establish it, otherwise to the combined sample; unsupported contextual forms still fail closed. For a supported recursive gate, the checker infers the sample first and uses its exact type, including field faces, for one monomorphic self reference. It generalizes after the body is checked; subsequent uses instantiate it independently. Incompatible recursive arguments can report the gate and argument sites. For a complete loobean branch with one direct self-call arm, a separately inferred closed base type can seed the recursive result before the whole body is checked. Open or pending base types do not seed it; other branch shapes remain subject to the fragment’s existing limits. A supported single local recursive gate also uses a monomorphic self reference and generalizes variables free of the enclosing environment after checking its body; captured variables remain shared. The checker collects written capitals per `++` before inference, excluding nested definitions: a capital used in an enclosing definition is shared with its locals even when written later, while a capital introduced only in a local definition is generalized there. Sibling locals can introduce independent capitals with the same spelling; generic mold parameters keep their own scope. Top-level groups of syntactic gates are inferred together with monomorphic placeholders and shared substitutions, then generalized only after the whole group checks; downstream uses and library interfaces instantiate those schemes independently. A dependency graph identifies groups with two iterative depth-first passes; its conservative local-reference edges can reject otherwise valid programs. Local mutual groups, polymorphic recursion, value cycles, unresolved literal constraints and unresolved branch joins remain unsupported. Reporting repeats inference for a single recursive gate outside a group; grouped reports use the stored schemes. Its performance cost remains unmeasured. A single-arm cell pattern accepts two or more binders, the last capturing the remaining tail; duplicate and shadowed binders are rejected. Intermediate union or collection tails, nested patterns, wildcards and faced records remain unsupported. String interpolation accepts known atom auras, unrestricted `@`, tapes and isolated decimal literals; a known cell asks for a printer, and an explicitly generic atom asks for an aura. Loobeans, term singletons, non-tape collections, open types and a type fixed only later remain unsupported. A known closed union with two or more arms supports patterns that provably cover or exclude each remaining case, including payload binders, imported and generic cases, and binder-free catch-alls. Partial boolean patterns can split known `?` positions into their two noun values, up to 64 alternatives across the union; binders retain their original case type. Missing alternatives and covered arms are reported. Other partial patterns, expansions above the limit, binders spanning distinct cases, differing arm result types, some complex two-arm subjects and contextual union-pattern branches remain unsupported. The Grammar’s `step` block infers in this fragment, but its module is not yet checked. A bare tag proved absent from a known union reports the union and tag sites in casts, single-argument calls, unit payloads, list items and supported branch arms; imported unnamed unions print their cases. Known faced records support uniquely named field changes, including nested wings, with field context passed to replacements and the original record type retained. Missing fields, empty changes and definite mismatches report sites; the expected-type site is the edit because the original field declaration location is not retained. Unknown or partly unfaced spines, ambiguous fields and repeated edits remain unsupported. A known record cast supplies field context to its tuple or record initializer, including nested list and union fields; mismatch diagnostics use the cast mold because the original field declaration location is not retained. The cart-store example’s `init` and `update` now infer, while its kind, declarations and full module remain unchecked. Backtick unit construction uses the validated standard prelude unit template, infers its payload without losing pending constraints, and makes the prelude’s `some` available. Ordinary result annotations also let its `bind`, `biff`, `both`, `clap`, `clef` and `flit` infer. A known unit in a cast, call, list item or record field supplies context to its payload, including nested units and lists; mismatches identify the payload and context. Unrelated union identities, some variable-dependent fits, and missing or altered prelude unit templates remain unsupported. Contextual null-headed cells fit their cases, but do not supply a `|=%$` constructor; unresolved nulls remain pending and are reported separately from tags. A known union of `~` and a null-headed cell supports a complete `~` / `[~ value]` branch in either order, including shadow checks; unknown subjects, missing or duplicate arms, and unresolved branch results remain unsupported. This fragment infers the prelude’s `fall` and `need` signatures. With the validated prelude list and a known cast or gate sample, empty, nonempty and nested list literals infer their element types, including contextual union tags; a mismatched element names both sites. In that context `~` and zero-valued terms fit an empty list, and two-item unfaced cells form cons lists, including nested cons and imported-list contexts; invalid heads or tails name both sites. A known gate sample also supplies context to matching positions in a single tuple or record argument, including nested cells; zero literals can fit list positions. A bound zero constant remains unsupported rather than a definite mismatch, and an unknown callee does not supply context. Faced or longer cells and a missing or altered prelude list fail closed. A known list result also supplies context through complete loobean, unit-shaped and list-shaped branches, including recursive and nested branches. For a known standard list with a supported element type, a complete `~` / `[item rest]` branch infers the element and tail types in either arm order and checks binders for shadowing. Uncontextualized list construction, unknown subjects, unsupported element types and other or incomplete list patterns remain unsupported. A value with type variable `A` can fit a field whose type is that same `A`, including in generic union payloads and nested or repeated record fields. Other variable-dependent face merges remain unsupported. Forced equality of distinct written capitals now reports both source sites, following @iko’s decision; forcing one to a concrete type remains unsupported. Imported record spines with repeated faces fail closed where used, but only with a generic unsupported diagnostic. Hoon may erase unfaced nested-cell boundaries, so the check can conservatively reject valid names in distinct erased scopes. Supported closed unions print using an in-scope name or imported alias; an unnamed nongeneric union prints its cases, parenthesized when nested. The latter is print-only. Generic union types retain all arguments in their printed name; if that name is unavailable, the partial printer reports the limitation. Different import faces for the same origin remain compatible; compatibility across distinct union origins and some generic-argument comparisons remain unsupported. Nonrecursive generic aliases can reorder, repeat or omit parameters while retaining a union’s origin, including through local scopes and library interfaces. A generic union declared directly inside a body remains unsupported, as do differing-variable face constraints in a union payload. A transitive generic union whose name is unavailable is reported as unsupported instead of hiding its arguments. Unfixed decimal literals default to `@ud` in gate-free inferred types; mutually recursive local groups and recursive molds, general branch tag context, other constraint cases and defaulting inside gate types still need work. Collection recognition checks the originating core and fails closed on shadows or unsupported Ford subject shapes; a wrapper regression also rejects forged subjects, samples and tails. Its golden fixtures include three real Tlon files. A Clay test passes a Ford-built nested union through the reader into partial inference. The partial prelude includes `murn`, `join`, `snip`, `rear` and the newly agreed shared-type `clap`, parsed but still awaiting checker and backend validation, and [prelude-inventory.md](prelude-inventory.md) is a source audit, not the complete inventory or signatures. The milestone remains unfinished.

22+The repository spec records the subsequent type-system and prelude decisions; those changes also need synchronization to the Claude document. An initial inference fragment and a standalone Hoon type reader are being tested. The fragment explicitly reports that it does not check a module; partial bridges pass selected Hoon atoms, term singletons, nested faced or unfaced cells, supported disjoint unions and opaque standard collections from `/sur` molds and marks into inference. Collections retain their names and supported arguments for printing and unification; nested supported union arguments are retained too. The bridge trusts unchanged results from the source-aware reader; a materialized type graph alone cannot reveal cases Hoon already collapsed. The source-validated standard prelude `list` mold shares this representation with imported lists; other Jibb-written collection molds and most prelude collection operations remain unsupported; malformed names and arities fail closed. Selected self-recursive `/sur` molds cross as opaque module-and-name identities; aliases, foreign references, recursive marks, unfolding and construction remain unsupported. The reader handles mark samples, recursive molds whose origins can be verified through Ford imports, nested collections, direct ordered maps, certain ordered-map fields, direct `$^` unions whose cases can be proved disjoint, and one verified explicit union argument in a list, set, map or unit. Tagged `$%` cases can additionally use restricted local named payload molds, with a bounded source proof; unsupported or ambiguous dependencies fail closed. Ambiguous recursive origins fail closed; recognizable explicit unions are checked from source before Hoon can collapse their cases, as @iko confirmed for imported `$%`, `$?` and `$^`, while other nested unions, nested ordered maps, general union disjointness and complete import integration remain unfinished. Opt-in structured reader APIs preserve successful graphs and distinguish definite unsupported-aura and core evidence from failures the reader cannot prove; unverified union disjointness and name-only vase recognition remain unsupported. They revalidate and re-walk failed types. An opt-in partial checker entry point consumes unchanged reader results and reports definite aura or core errors at imported mold use sites when their inputs are unique. Ordered replay covers nested cell samples, record and function casts, and non-generic same-module aliases; unsupported prefixes, cycles and shadowing stop it. Union molds, generic applications, transitive modules and unsupported reader outcomes remain generic. Replay repeats inference and may add work. The partial checker resolves a subset of ordinary library imports in dependency order using supplied Jibb sources and a source-derived partial prelude interface, caches completed interfaces per run, and detects missing sources and cycles. It does not yet check API or kind semantics, and the prelude inventory is incomplete. The inference fragment supports unrestricted `@`, selected one-way widenings including aura-family ancestors, generalized atom constraints arising from explicit capitals or bare sample binders, acyclic local value definitions with captures, selected single self-recursive top-level and local gates, simple and nonrecursive generic mold aliases, selected faced record casts and field reads, and contextual tags, `~` and constructors for closed disjoint unions, including direct nonrecursive generic unions and propagation through complete loobean and unit-shaped branches in casts and known union-sample calls, including nested branches. Multi-argument calls form a right-nested sample, retain known faces and shared type variables, and can use known sample positions to contextualize list and union arguments. A definite mismatch points to the failing argument when the fragment can establish it, otherwise to the combined sample; unsupported contextual forms still fail closed. For a supported recursive gate, the checker infers the sample first and uses its exact type, including field faces, for one monomorphic self reference. It generalizes after the body is checked; subsequent uses instantiate it independently. Incompatible recursive arguments can report the gate and argument sites. For a complete loobean branch with one direct self-call arm, a separately inferred closed base type can seed the recursive result before the whole body is checked. Open or pending base types do not seed it; other branch shapes remain subject to the fragment’s existing limits. A supported single local recursive gate also uses a monomorphic self reference and generalizes variables free of the enclosing environment after checking its body; captured variables remain shared. The checker collects written capitals per `++` before inference, excluding nested definitions: a capital used in an enclosing definition is shared with its locals even when written later, while a capital introduced only in a local definition is generalized there. Sibling locals can introduce independent capitals with the same spelling; generic mold parameters keep their own scope. Top-level groups of syntactic gates are inferred together with monomorphic placeholders and shared substitutions, then generalized only after the whole group checks; downstream uses and library interfaces instantiate those schemes independently. A dependency graph identifies groups with two iterative depth-first passes; its conservative local-reference edges can reject otherwise valid programs. Local mutual groups, polymorphic recursion, value cycles, unresolved literal constraints and unresolved branch joins remain unsupported. Reporting repeats inference for a single recursive gate outside a group; grouped reports use the stored schemes. Its performance cost remains unmeasured. A single-arm cell pattern accepts two or more binders, the last capturing the remaining tail; duplicate and shadowed binders are rejected. Intermediate union or collection tails, nested patterns, wildcards and faced records remain unsupported. String interpolation accepts known atom auras, unrestricted `@`, tapes and isolated decimal literals; a known cell asks for a printer, and an explicitly generic atom asks for an aura. Loobeans, term singletons, non-tape collections, open types and a type fixed only later remain unsupported. A known closed union with two or more arms supports patterns that provably cover or exclude each remaining case, including payload binders, imported and generic cases, and binder-free catch-alls. Partial boolean patterns can split known `?` positions into their two noun values, up to 64 alternatives across the union; binders retain their original case type. Missing alternatives and covered arms are reported. Other partial patterns, expansions above the limit, binders spanning distinct cases, differing arm result types, some complex two-arm subjects and contextual union-pattern branches remain unsupported. The Grammar’s `step` block infers in this fragment, but its module is not yet checked. A bare tag proved absent from a known union reports the union and tag sites in casts, single-argument calls, unit payloads, list items and supported branch arms; imported unnamed unions print their cases. Known faced records support uniquely named field changes, including nested wings, with field context passed to replacements and the original record type retained. Missing fields, empty changes and definite mismatches report sites; the expected-type site is the edit because the original field declaration location is not retained. Unknown or partly unfaced spines, ambiguous fields and repeated edits remain unsupported. A known record cast supplies field context to its tuple or record initializer, including nested list and union fields; mismatch diagnostics use the cast mold because the original field declaration location is not retained. The cart-store example’s `init` and `update` now infer, while its kind, declarations and full module remain unchecked. Backtick unit construction uses the validated standard prelude unit template, infers its payload without losing pending constraints, and makes the prelude’s `some` available. Ordinary result annotations also let its `bind`, `biff`, `both`, `clap`, `clef` and `flit` infer. A known unit in a cast, call, list item or record field supplies context to its payload, including nested units and lists; mismatches identify the payload and context. Unrelated union identities, some variable-dependent fits, and missing or altered prelude unit templates remain unsupported. Contextual null-headed cells fit their cases, but do not supply a `|=%$` constructor; unresolved nulls remain pending and are reported separately from tags. A known union of `~` and a null-headed cell supports a complete `~` / `[~ value]` branch in either order, including shadow checks; unknown subjects, missing or duplicate arms, and unresolved branch results remain unsupported. This fragment infers the prelude’s `fall` and `need` signatures. With the validated prelude list and a known cast or gate sample, empty, nonempty and nested list literals infer their element types, including contextual union tags; a mismatched element names both sites. In that context `~` and zero-valued terms fit an empty list, and two-item unfaced cells form cons lists, including nested cons and imported-list contexts; invalid heads or tails name both sites. A known gate sample also supplies context to matching positions in a single tuple or record argument, including nested cells; zero literals can fit list positions. A bound zero constant remains unsupported rather than a definite mismatch, and an unknown callee does not supply context. Faced or longer cells and a missing or altered prelude list fail closed. A known list result also supplies context through complete loobean, unit-shaped and list-shaped branches, including recursive and nested branches. For a known standard list with a supported element type, a complete `~` / `[item rest]` branch infers the element and tail types in either arm order and checks binders for shadowing. Uncontextualized list construction, unknown subjects, unsupported element types and other or incomplete list patterns remain unsupported. A value with type variable `A` can fit a field whose type is that same `A`, including in generic union payloads and nested or repeated record fields. Other variable-dependent face merges remain unsupported. Forced equality of distinct written capitals now reports both source sites, following @iko’s decision; forcing one to a concrete type remains unsupported. Imported record spines with repeated faces fail closed where used, but only with a generic unsupported diagnostic. Hoon may erase unfaced nested-cell boundaries, so the check can conservatively reject valid names in distinct erased scopes. Supported closed unions print using an in-scope name or imported alias; an unnamed nongeneric union prints its cases, parenthesized when nested. The latter is print-only. Generic union types retain all arguments in their printed name; if that name is unavailable, the partial printer reports the limitation. Different import faces for the same origin remain compatible; compatibility across distinct union origins and some generic-argument comparisons remain unsupported. Nonrecursive generic aliases can reorder, repeat or omit parameters while retaining a union’s origin, including through local scopes and library interfaces. A generic union declared directly inside a body remains unsupported, as do differing-variable face constraints in a union payload. A transitive generic union whose name is unavailable is reported as unsupported instead of hiding its arguments. Unfixed decimal literals default to `@ud` in gate-free inferred types; mutually recursive local groups and recursive molds, general branch tag context, other constraint cases and defaulting inside gate types still need work. Collection recognition checks the originating core and fails closed on shadows or unsupported Ford subject shapes; a wrapper regression also rejects forged subjects, samples and tails. Its golden fixtures include three real Tlon files. A Clay test passes a Ford-built nested union through the reader into partial inference. The partial prelude includes `murn`, `join`, `snip`, `rear` and the newly agreed shared-type `clap`, parsed but still awaiting checker and backend validation, and [prelude-inventory.md](prelude-inventory.md) is a source audit, not the complete inventory or signatures. The milestone remains unfinished.

2323

2424The shared prelude interface reserves every name present in the supplied vendored source and makes only supported inferred entries available, including `list`, `unit`, `same`, `fall`, `need`, `lure`, `weld`, `snoc` and `turn`. The validated standard `list` mold is injected when the prelude’s own gates are inferred; `weld` and `turn` have ordinary explicit result casts. An absent or altered `list` is not injected, and an altered declaration cannot leak through direct or transitive mold aliases. List-dependent prelude mold aliases remain unsupported because their templates are prepared before injection. Unsupported entries such as most list helpers remain reserved but unavailable; backend validation of the helpers remains outstanding. All callers use the same prelude origin, so a library can export a type containing unqualified `(unit A)` to another module. Preparation rejects empty, malformed, conflicting or import-bearing source; the prepared value is trusted and must come unchanged from `+prepare-prelude`. The module-scope fixture compares the prepared and source-taking paths against the real prelude and a two-module golden under eval and on the ship. The source and checker remain incomplete, so this does not establish complete shadowing coverage or a checked module.

2525

@@ -40,7 +40,7 @@ What the plan asks for, and where it is:

4040Besides the plan's list:

4141

4242- 542 golden cases: 326 that parse and 216 that fail, each failure at a stated line and column. One failing case has an unclear expectation (corpus question 3). The newer type-output cases exercise only the partial inference fragment. Each case's `about.txt` quotes the doc's words it tests.

43−- The 542-case corpus passed under `urbit eval` in 61.9 s. The fake ship passed all 548 tests, including the importer, importer/checker and mark/checker bridges, module scope and unification checks, with 35.3 s for sync and 41.5 s for tests. The importer golden compares 149 projections; `tools/clay-fixtures` builds the example Hoon fixtures through Clay, checks a recursive Ford import's origin, and passes Clay-built types through the Clay-built importer and partial checker.

43+- The 542-case corpus passed under `urbit eval` in 62.7 s. The fake ship passed all 548 tests, including the importer, importer/checker and mark/checker bridges, module scope and unification checks, with 40.0 s for sync and 50.3 s for tests. The importer golden compares 169 projections; `tools/clay-fixtures` builds the example Hoon fixtures through Clay, checks a recursive Ford import's origin, and passes Clay-built types through the Clay-built importer and partial checker.

4444- `tools/testdata/selftest` (22 checks) and `tools/testdata/ship-selftest` test the tools themselves.

4545- Two independent audits before 7c739b7, one of which compared the library with a reference parser written in Python from the doc over about 19,000 generated programs. Before ab797a9, a second Python parser, written from the decisions, agreed with the library on 8,000 generated programs and 900 hand-written probes.

4646- Speed: starting `urbit eval` and building the library takes about 8 s. After that, a 2,000-line module of 400 definitions parses in about a second. Loops over definitions, arms, lines and items grow no stack; nesting costs a few stack frames a level, and 100,000 nested brackets still parse (library section 3).

@@ -100,7 +100,8 @@ Besides the plan's list:

100100| 0bc5113 | 2026-10-31 | Contextualize record initializers and infer unit construction |

101101| 264a436 | 2026-10-31 | Contextualize unit payloads in casts, calls and nested values |

102102| a140383 | 2026-10-31 | Report missing union tags and infer prelude unit helpers |

103−| This change | 2026-10-31 | Infer longer cell binder patterns and prelude unit helpers |

103+| d69cc52 | 2026-10-31 | Infer longer cell binder patterns and prelude unit helpers |

104+| This change | 2026-10-31 | Import source-verified tagged Hoon unions |

104105

105106## Checking it

106107

jibb-dev/lib/jibb-import.hoon+246−2

@@ -76,6 +76,193 @@

7676 ^- (each imported @t)

7777 (read-with module name typ ~)

7878::

79+:: When Hoon's expanded type has lost source cases, inspect the exact

80+:: selected local arm. Restrict this fallback to distinct literal head tags

81+:: and proven-safe dependencies, then verify each projected branch again.

82++$ tagged-case [tag=@ branch=spec]

83+:: Clay and eval expose different versions of the spec union. Inspect a

84+:: help wrapper as a noun before checking its contained spec.

85+++ source-gist-tail

86+ |= raw=*

87+ ^- (unit *)

88+ ?. ?=([%gist [%help *] *] raw) ~

89+ `+.+.raw

90+::

91+++ tagged-head

92+ |= branch=spec

93+ ^- (unit @)

94+ =/ gist=(unit *) (source-gist-tail branch)

95+ ?^ gist $(branch ;;(spec u.gist))

96+ ?+ branch ~

97+ [%bccl *]

98+ ?~ t.p.branch ~

99+ ?. ?=([%leaf %tas @] i.p.branch) ~

100+ `q.i.p.branch

101+ ==

102+::

103+++ tagged-cases

104+ |= [cases=(list spec) tags=(list @)]

105+ ^- (unit (list tagged-case))

106+ ?~ cases `~

107+ ?: |((has-spec-cell-union i.cases) (has-spec-general-union i.cases)) ~

108+ =/ tag=(unit @) (tagged-head i.cases)

109+ ?~ tag ~

110+ ?: (lien tags |=(x=@ =(x u.tag))) ~

111+ =/ rest $(cases t.cases, tags [u.tag tags])

112+ ?~ rest ~

113+ `[[u.tag i.cases] u.rest]

114+::

115+:: Benign source annotations have different typed representations on

116+:: Clay and under eval. Inspect the wrapper as a noun, and validate the

117+:: contained Hoon before examining an arm.

118+++ source-note-tail

119+ |= raw=*

120+ ^- (unit *)

121+ ?: ?=([%note [%help *] *] raw) `+.+.raw

122+ ?: ?=([%dbug * *] raw) `+.+.raw

123+ ~

124+::

125+++ tagged-source-code

126+ |= [code=hoon name=term]

127+ ^- (unit (list tagged-case))

128+ =/ note=(unit *) (source-note-tail code)

129+ ?^ note $(code ;;(hoon u.note))

130+ ?+ code ~

131+ [%ktcl *]

132+ ?. ?=([%name * [%bccn *]] p.code) ~

133+ ?. =(name p.p.code) ~

134+ =/ cases=(list spec) p.q.p.code

135+ ?~ cases ~

136+ ?~ t.cases ~

137+ (tagged-cases cases ~)

138+ ==

139+::

140+:: Source proof for dependencies of an explicitly tagged union. Only

141+:: simple local molds, standard collections and distinct term enums are

142+:: accepted; computed molds, nested cell unions and cycles fail closed.

143+:: One shared fuel budget bounds repeated visits through acyclic aliases;

144+:: exhaustion or an inherited same-name arm leaves the result unsupported.

145+++ local-arm-source

146+ |= [cor=type name=term]

147+ ^- (unit hoon)

148+ ?. ?=([%core *] cor) ~

149+ =/ chapters=(map term tome) q.r.q.cor

150+ =/ all=(list [term tome]) ~(tap by chapters)

151+ ?: (lien all |=(e=[term tome] &(!=(-.e %$) (chapter-unsafe +.e name)))) ~

152+ =/ chapter=(unit tome) (~(get by chapters) %$)

153+ ?~ chapter ~

154+ (chapter-source u.chapter name)

155+::

156+++ local-mold-spec

157+ |= [code=hoon name=term]

158+ ^- (unit spec)

159+ =/ note=(unit *) (source-note-tail code)

160+ ?^ note $(code ;;(hoon u.note))

161+ ?+ code ~

162+ [%ktcl *]

163+ ?. ?=([%name * *] p.code) ~

164+ ?. =(name p.p.code) ~

165+ `q.p.code

166+ ==

167+::

168+++ safe-source-enum

169+ |= [cases=(list spec) seen=(list @) fuel=@ud]

170+ ^- (unit @ud)

171+ ?~ cases `fuel

172+ ?: =(fuel 0) ~

173+ ?. ?=([%leaf %tas @] i.cases) ~

174+ ?: (lien seen |=(n=@ =(n q.i.cases))) ~

175+ $(cases t.cases, seen [q.i.cases seen], fuel (dec fuel))

176+::

177+++ safe-source-specs

178+ |= [xs=(list spec) cor=type seen=(list term) fuel=@ud]

179+ ^- (unit @ud)

180+ ?~ xs `fuel

181+ =/ left=(unit @ud) (safe-source-spec i.xs cor seen fuel)

182+ ?~ left ~

183+ $(xs t.xs, fuel u.left)

184+::

185+++ safe-source-name

186+ |= [name=term cor=type seen=(list term) fuel=@ud]

187+ ^- (unit @ud)

188+ ?: (lien seen |=(x=term =(name x))) ~

189+ =/ arm=(unit hoon) (local-arm-source cor name)

190+ ?~ arm

191+ ?. &(|(=(name %ship) =(name %path)) (scope-safe cor name)) ~

192+ `fuel

193+ ?. ?=([%core *] cor) ~

194+ ?. (scope-safe p.cor name) ~

195+ =/ body=(unit spec) (local-mold-spec u.arm name)

196+ ?~ body ~

197+ (safe-source-spec u.body cor [name seen] fuel)

198+::

199+++ safe-source-spec

200+ |= [shape=spec cor=type seen=(list term) fuel=@ud]

201+ ^- (unit @ud)

202+ ?: =(fuel 0) ~

203+ =. fuel (dec fuel)

204+ =/ gist=(unit *) (source-gist-tail shape)

205+ ?^ gist $(shape ;;(spec u.gist))

206+ ?+ shape ~

207+ [%base *] ?:(?=([%atom *] p.shape) `fuel ~)

208+ [%leaf *] `fuel

209+ [%bcts *] ?@ p.shape $(shape q.shape)

210+ ~

211+ [%bccl *] (safe-source-specs p.shape cor seen fuel)

212+ [%bcwt *] (safe-source-enum p.shape ~ fuel)

213+ [%like *]

214+ ?. ?=([@ ~] p.shape) ~

215+ ?. ?=(~ q.shape) ~

216+ (safe-source-name i.p.shape cor seen fuel)

217+ [%make *]

218+ ?. ?=([%wing [@ ~]] p.shape) ~

219+ =/ n=term i.p.p.shape

220+ ?. (lien `(list term)`~[%map %set %qeu %list %unit %jar %jug] |=(x=term =(x n))) ~

221+ ?. (scope-safe cor n) ~

222+ (safe-source-specs q.shape cor seen fuel)

223+ ==

224+::

225+++ safe-source-tagged

226+ |= [cases=(list tagged-case) cor=type seen=(list term) fuel=@ud]

227+ ^- ?

228+ ?~ cases &

229+ =/ left=(unit @ud) (safe-source-spec branch.i.cases cor seen fuel)

230+ ?~ left |

231+ $(cases t.cases, fuel u.left)

232+::

233+++ tagged-union-fallback

234+ |= [module=term name=term cor=type]

235+ ^- (unit (each imported @t))

236+ ?. ?=([%core *] cor) ~

237+ =/ chapters=(map term tome) q.r.q.cor

238+ =/ other=(list [term tome]) ~(tap by chapters)

239+ ?: (lien other |=(e=[term tome] &(!=(-.e %$) (chapter-unsafe +.e name)))) ~

240+ =/ chapter=(unit tome) (~(get by chapters) %$)

241+ ?~ chapter ~

242+ =/ selected=(unit hoon) (chapter-source u.chapter name)

243+ ?~ selected ~

244+ =/ cases (tagged-source-code u.selected name)

245+ ?~ cases ~

246+ ?. (safe-source-tagged u.cases cor ~[name] 4.096) ~

247+ =/ tried=(each (list type) tang)

248+ (mule |.((turn u.cases |=(c=tagged-case (~(play ut cor) [%kttr branch.c])))))

249+ ?. ?=([%& *] tried) ~

250+ =/ projected=(each (list imported) tang)

251+ (mule |.((turn p.tried |=(t=type (walk module t catalog ~ `cor)))))

252+ ?. ?=([%& *] projected) ~

253+ ?^ (first-bads p.projected) ~

254+ ?. (all-disjoint p.projected) ~

255+ =/ xs=(list tagged-case) u.cases

256+ =/ ys=(list imported) p.projected

257+ |-

258+ ?~ xs

259+ ?^ ys ~

260+ `[%& [%fork (sort p.projected |=(pair=[imported imported] (dor -.pair +.pair)))]]

261+ ?~ ys ~

262+ ?. ?=([%cell [%atom %tas [~ @]] *] i.ys) ~

263+ ?. =(tag.i.xs u.value.head.i.ys) ~

264+ $(xs t.xs, ys t.ys)

265+::

79266:: +read-mold-in: accept the /sur core as provenance. The core must be

80267:: built against zuse or validated Ford imports, and its selected arm

81268:: must be this type. Unknown subject shapes fail closed.

@@ -91,8 +278,12 @@

91278 ?. =(typ (~(play ut cor) (ream (cat 3 '*' name))))

92279 [%| 'Hoon module provenance does not match the selected mold']

93280 =/ result (read-with module name typ [~ cor])

94− ?. ?=([%& *] result) result

95− result

281+ ?: ?=([%& *] result) result

282+ =/ fallback=(each (unit (each imported @t)) tang)

283+ (mule |.((tagged-union-fallback module name cor)))

284+ ?: ?=(%| -.fallback) result

285+ ?~ p.fallback result

286+ u.p.fallback

96287::

97288:: +read-named is the source-aware entry point for callers that have

98289:: not selected a Hoon type yet. Check the core and the local arm

@@ -663,6 +854,32 @@

663854 ?. (arm-map-valid +.chapter) ~

664855 [~ (arm-map-has +.chapter target)]

665856::

857+:: Return a unique source arm from either validated tome wrapper. Walk

858+:: the noun map rather than relying on fields that differ on Clay.

859+++ arm-map-sources

860+ |= [m=* target=term]

861+ ^- (list hoon)

862+ ?@ m ~

863+ =/ kv=* -.m

864+ =/ children=* +.m

865+ =/ found=(list hoon) ?:(=(-.kv target) ~[;;(hoon +.kv)] ~)

866+ (weld found (weld $(m -.children) $(m +.children)))

867+::

868+++ chapter-source

869+ |= [chapter=* target=term]

870+ ^- (unit hoon)

871+ ?: (arm-map-valid chapter) (unique-arm-source chapter target)

872+ ?@ chapter ~

873+ ?. (arm-map-valid +.chapter) ~

874+ (unique-arm-source +.chapter target)

875+::

876+++ unique-arm-source

877+ |= [arms=* target=term]

878+ ^- (unit hoon)

879+ =/ sources=(list hoon) (arm-map-sources arms target)

880+ ?. ?=([* ~] sources) ~

881+ `i.sources

882+::

666883++ chapter-unsafe

667884 |= [chapter=* target=term]

668885 ^- ?

@@ -1366,6 +1583,13 @@

13661583 =/ distinct=type -:(ride distinct-parent origin-first)

13671584 =/ trans-amb-parent=type [%cell [%face %intermediate fc] [%cell [%face %second sc] -:!>(..zuse)]]

13681585 =/ trans-amb=type -:(ride trans-amb-parent origin-trans)

1586+ =/ tag-child=@t

1587+ '|%\0a+$ tag-invalid-cell @t\0a+$ choice $%([%ok a=tag-invalid-cell] [%err a=@ud])\0a--\0a'

1588+ =/ tag-collision=type -:(ride [%cell [%face %base sc] -:!>(..zuse)] tag-child)

1589+ =/ tag-clean=type -:(ride [%cell [%face %base other] -:!>(..zuse)] tag-child)

1590+ =/ tag-zuse=@t

1591+ '|%\0a+$ ship @t\0a+$ path @ud\0a+$ choice $%([%ok who=ship] [%err where=path])\0a--\0a'

1592+ =/ tag-zuse-core=type -:(ride -:!>(..zuse) tag-zuse)

13691593 =/ sample

13701594 |= name=term

13711595 (read-mold-in %small name (~(play ut sc) (ream (cat 3 '*' name))) sc)

@@ -1526,6 +1750,26 @@

15261750 (crip "missing-arm: {(show-result (read-mold-in %small %missing [%atom %ud ~] sc))}")

15271751 (crip "wrong-provenance: {(show-result (read-mold-in %small %action (~(play ut sc) (ream '*items')) sc))}")

15281752 (crip "unverified-subject: {(show-result (read-mold-in %std %jar (~(play ut -:!>(..zuse)) (ream '*(jar @ud @t)')) -:!>(..zuse)))}")

1753+ (crip "tag-ford-collision: {(show-result (read-named %child %choice tag-collision))}")

1754+ (crip "tag-ford-clean: {(show-result (read-named %child %choice tag-clean))}")

1755+ (crip "tag-zuse-local: {(show-result (read-named %child %choice tag-zuse-core))}")

1756+ (crip "tag-valid: {(show-result (sample %tag-valid))}")

1757+ (crip "tag-duplicate: {(show-result (sample %tag-duplicate))}")

1758+ (crip "tag-collapsed: {(show-result (sample %tag-collapsed))}")

1759+ (crip "tag-invalid-direct: {(show-result (sample %tag-invalid-direct))}")

1760+ (crip "tag-invalid-alias: {(show-result (sample %tag-invalid-alias))}")

1761+ (crip "tag-invalid-list: {(show-result (sample %tag-invalid-list))}")

1762+ (crip "tag-enum-good: {(show-result (sample %tag-enum-good))}")

1763+ (crip "tag-enum-bad: {(show-result (sample %tag-enum-bad))}")

1764+ (crip "tag-nested-good: {(show-result (sample %tag-nested-good))}")

1765+ (crip "tag-shadow-jar: {(show-result (read-named %shadow-static %tag-shadow-jar xc))}")

1766+ (crip "tag-shadow-jug: {(show-result (read-named %shadow-static %tag-shadow-jug xc))}")

1767+ (crip "tag-fuel-small: {?:(?=(^ (safe-source-name %tag-fuel-2 sc ~ 64)) "yes" "no")}")

1768+ (crip "tag-fuel-large: {?:(?=(~ (safe-source-name %tag-fuel-11 sc ~ 64)) "rejected" "wrong")}")

1769+ (crip "presence-action-1: {(show-result (present %action-1))}")

1770+ (crip "presence-command-1: {(show-result (present %command-1))}")

1771+ (crip "presence-update-1: {(show-result (present %update-1))}")

1772+ (crip "presence-response-1: {(show-result (present %response-1))}")

15291773 (crip "presence-topic: {(show-result (present %topic))}")

15301774 (crip "presence-timing: {(show-result (present %timing))}")

15311775 (crip "presence-places: {(show-result (present %places))}")

tests/importer/about.txt+5−1

@@ -9,7 +9,11 @@ explicit union argument when the exact call wrapper and collection provenance

99are validated and all union cases are static and pairwise disjoint. Cases

1010cover overlap, collapsed branches, multiple or nested unions, dependent

1111branches, forged subject, sample and tail wrappers, and a shadowed

12−collection. Unsupported forms fail closed; nested `$@` cases remain supported. The union disjointness rule was confirmed in question 22. `ford.txt`

12+collection. Tagged source cases exercise named payload dependencies, valid and collapsed enums,

13+direct and transitively aliased overlaps, nested collections, shadowed jar and

14+jug dependencies, Ford-name collisions, zuse local-name precedence and the

15+shared proof budget. Four real `presence` unions exercise the same path.

16+Unsupported forms fail closed; nested `$@` cases remain supported. The union disjointness rule was confirmed in question 22. `ford.txt`

1317checks a synthetic imported subject and selected mold; other cases check

1418transitive imports, named mold lookup, missing names, shadowing, unprovenanced

1519recursive holds, malformed

tests/importer/shadow-static.txt+4

@@ -4,4 +4,8 @@

44+$ path-shadow [?(%fil %dir) pa=path nam=@t]

55+$ bad [a=((mop @ud @t) lte) b=(list @ud)]

66+$ collection-union-shadow (list $?([%x @ud] [%y @t]))

7+++ map map:..zuse

8+++ set set:..zuse

9++$ tag-shadow-jar $%([%ok a=(jar @ud @t)] [%err a=@ud])

10++$ tag-shadow-jug $%([%ok a=(jug @ud @t)] [%err a=@ud])

711--

tests/importer/small.txt+26

@@ -75,4 +75,30 @@

7575+$ collection-union-multiple (map $?([%x @ud] [%y @t]) $?([%a @ud] [%b @t]))

7676+$ collection-union-nested (list [id=@ud value=$?([%x @ud] [%y @t])])

7777+$ collection-union-dependent (list $?(action [%x @t]))

78++$ tag-word @t

79++$ tag-valid $%([%ok a=tag-word] [%err a=@ud])

80++$ tag-duplicate $%([%x a=@ud] [%x b=@t])

81++$ tag-collapsed $%([%x a=@ud] [%x a=@ud])

82++$ tag-invalid-cell $^(@ud @ud)

83++$ tag-invalid-chain tag-invalid-cell

84++$ tag-invalid-direct $%([%ok a=$^(@ud @ud)] [%err a=@t])

85++$ tag-invalid-alias $%([%ok a=tag-invalid-chain] [%err a=@t])

86++$ tag-invalid-list $%([%ok a=(list tag-invalid-cell)] [%err a=@t])

87++$ tag-valid-enum ?(%a %b)

88++$ tag-invalid-enum ?(%a %a)

89++$ tag-enum-good $%([%ok a=tag-valid-enum] [%err a=@t])

90++$ tag-enum-bad $%([%ok a=tag-invalid-enum] [%err a=@t])

91++$ tag-nested-good $%([%ok a=(list (unit @t))] [%err a=@t])

92++$ tag-fuel-0 @t

93++$ tag-fuel-1 [tag-fuel-0 tag-fuel-0]

94++$ tag-fuel-2 [tag-fuel-1 tag-fuel-1]

95++$ tag-fuel-3 [tag-fuel-2 tag-fuel-2]

96++$ tag-fuel-4 [tag-fuel-3 tag-fuel-3]

97++$ tag-fuel-5 [tag-fuel-4 tag-fuel-4]

98++$ tag-fuel-6 [tag-fuel-5 tag-fuel-5]

99++$ tag-fuel-7 [tag-fuel-6 tag-fuel-6]

100++$ tag-fuel-8 [tag-fuel-7 tag-fuel-7]

101++$ tag-fuel-9 [tag-fuel-8 tag-fuel-8]

102++$ tag-fuel-10 [tag-fuel-9 tag-fuel-9]

103++$ tag-fuel-11 [tag-fuel-10 tag-fuel-10]

78104--

tests/importer/tree.txt+20

@@ -140,6 +140,26 @@ diagnostic-spoof: unsupported: signed and float auras cannot be imported

140140missing-arm: error: Hoon mold `missing` is not declared

141141wrong-provenance: error: Hoon module provenance does not match the selected mold

142142unverified-subject: error: Hoon module provenance is unavailable

143+tag-ford-collision: error: a Hoon union needs a source-level disjointness check

144+tag-ford-clean: (union [ok a=@t] [err a=@ud])

145+tag-zuse-local: (union [ok who=@t] [err where=@ud])

146+tag-valid: (union [ok a=@t] [err a=@ud])

147+tag-duplicate: error: Hoon union disjointness could not be verified

148+tag-collapsed: error: Hoon union disjointness could not be verified

149+tag-invalid-direct: error: a Hoon union needs a source-level disjointness check

150+tag-invalid-alias: error: a Hoon union needs a source-level disjointness check

151+tag-invalid-list: error: a Hoon union needs a source-level disjointness check

152+tag-enum-good: (union [ok a=(union a b)] [err a=@t])

153+tag-enum-bad: error: a Hoon union needs a source-level disjointness check

154+tag-nested-good: (union [ok a=(list (unit @t))] [err a=@t])

155+tag-shadow-jar: error: Hoon collection provenance is unavailable or shadowed

156+tag-shadow-jug: error: Hoon collection provenance is unavailable or shadowed

157+tag-fuel-small: yes

158+tag-fuel-large: rejected

159+presence-action-1: (union [set [disclose=(set @p) [key=[context=(list @ta) [ship=@p topic=(union other typing computing)]] [timeout=(unit @dr) display=[icon=(unit @t) [text=(unit @t) blob=(unit @t)]]]]]] [nuke context=(list @ta)] [clear key=[context=(list @ta) [ship=@p topic=(union other typing computing)]]])

160+presence-command-1: (union [set [disclose=(set @p) [key=[context=(list @ta) [ship=@p topic=(union other typing computing)]] [timing=[since=@da timeout=(unit @dr)] display=[icon=(unit @t) [text=(unit @t) blob=(unit @t)]]]]]] [clear key=[context=(list @ta) [ship=@p topic=(union other typing computing)]]])

161+presence-update-1: (union [set [key=[context=(list @ta) [ship=@p topic=(union other typing computing)]] [timing=[since=@da timeout=(unit @dr)] display=[icon=(unit @t) [text=(unit @t) blob=(unit @t)]]]]] [clear key=[context=(list @ta) [ship=@p topic=(union other typing computing)]]])

162+presence-response-1: (union [gone key=[context=(list @ta) [ship=@p topic=(union other typing computing)]]] [here [key=[context=(list @ta) [ship=@p topic=(union other typing computing)]] [timing=[since=@da timeout=(unit @dr)] display=[icon=(unit @t) [text=(unit @t) blob=(unit @t)]]]]] [init places=(map (list @ta) (map (union other typing computing) (map @p [[since=@da timeout=(unit @dr)] [icon=(unit @t) [text=(unit @t) blob=(unit @t)]]])))])

143163presence-topic: (union other typing computing)

144164presence-timing: [since=@da timeout=(unit @dr)]

145165presence-places: (map (list @ta) (map (union other typing computing) (map @p [[since=@da timeout=(unit @dr)] [icon=(unit @t) [text=(unit @t) blob=(unit @t)]]])))

tools/importer-test+1−1

@@ -34,4 +34,4 @@ if result.stdout != expected:

3434 result.stdout.decode().splitlines(keepends=True),

3535 fromfile='expected tree.txt', tofile='actual types'))

3636 sys.exit(1)

37−print('importer golden: 149 projections passed')

37+print('importer golden: 169 projections passed')