# Glossary ## Coming from React or other codegen tools [#coming-from-react-or-other-codegen-tools] Analogues, not equivalences — landing pads for readers arriving with React or generic-codegen priors. Once a term lands, switch to the SKMTC-native definition below; the analogues lose detail. | Term | ≈ Analogue | The catch | | ----------------------------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------------- | | Projection | An exportable React component | In memory until Render; coordinate by name, not source text | | Snippet | A JSX expression embedded in a parent | No file-scope name; registers imports against the parent's `destinationPath` | | `SnippetBase` | The shared base of component and expression | The literal DSL spine — Projections and Snippets both descend from it | | `toTs*ProjectionBase` factories | Factories returning specialized component base classes | Three flavors — pick by what drives the Definition: refName, OAS operation, or GQL operation | | `Definition` | The `export const Component = …` wrapper | The Driver adds the `export const`; don't write it in `toString()` | | `ContentSettings` | A props bag computed before construction | Built from the Projection's static methods, then handed to the constructor | | `Identifier` | A name + per-language kind | The kind drives declaration keywords and imports under `verbatimModuleSyntax` | | `Stringable` | Anything with `.toString()` | The composition contract for template-literal interpolation | | `CustomValue` | An inline TS fragment not from the schema | Wraps hand-written expressions so they compose with the DSL | | Import | `import { X } from 'y'` | Register via `register({ imports })`; raw `import` lines in templates land in the file body | | `Driver` | A render function that constructs and mounts | Cache lookup → construct on miss → register Definition and imports | | `GenerateContext` | A Redux store + React's reconciler | Owns the dispatch loop, file map, manifest results, StackTrail | | `transform` | A `useEffect` body per `(operation, variant)` | Returns `void`; output happens via `register` / `insert*` calls | | `isSupported` | A feature-flag check | Capability gate, not user intent — user intent is `include` / `skip` | | `toIdentifierName` / `toExportPath` | Pure `(name, file)` functions | Must be pure — the cross-generator cache depends on it | | `toEnrichments` | A `useSelector` keyed to this operation + variant | Walks the enrichment routing hierarchy for its protocol | | `Inserted` | A `useQuery` result handle | `.toName()` for the identifier; `.settings` and `.definition` for the rest | | `GeneratorKey` | A composite primary key | Pipe-delimited; compared in `affirmDefinition` to detect collisions | | `findDefinition` | A cache `.get(key)` | Looks up by `(name, exportPath)`; `undefined` on miss | | `affirmDefinition` | A cache integrity check | Key mismatch throws "Registered definition mismatch" | | Cache key vs. `GeneratorKey` | Map key vs. row identity | The cache key is narrower by design; the integrity check catches collisions loudly | | Variant | A case of "one source item, several artifacts" | Named string axis; `'main'` is always present | | Variants-aware generator | A component that renders per prop | Folds `variant` into `toIdentifierName`, typically via `withVariant` | | Variants-unaware generator | A component that ignores the variant prop | Every caller's variant resolves to the shared `'main'` Definition | | `withVariant(base, variant)` | PascalCase-aware concatenation | `withVariant('Form', 'main')` → `'Form'`; kebab-case variants become PascalCase suffixes | | `'main'` | The always-present default branch | Engine-guaranteed; filled in when no enrichments are configured | | Project | A workspace folder for one schema-to-code mapping | Lives at `/.skmtc//`; not the consumer app | | `client.json#settings` | A `tsconfig.json`-style config | Carries `basePath`, `source`, `enrichments`, `include`, `skip` | | `enrichments` | Per-item prop overrides | Routed per protocol: path/method (OAS), rootKind/fieldName (GQL), or refName (models) | | `basePath` | The `@` alias root in `tsconfig.paths` | Required, relative; must match the consumer bundler's alias | | `include` | An allow-list | Empty array = no filter | | `skip` | A deny-list | `skip` wins over `include` | | `manifest.json` | A build-output manifest like `stats.json` | Read it for diagnostics before guessing | | Parse phase | A schema → AST step | Lenient input, strict diagnostics | | Generate phase | The reconcile / render pass | Produces the in-memory `File` map; where every `transform` runs | | Render phase | Writing the AST out to source files | No formatter runs — consumers format their own output | | `ParseIssue` | A non-fatal compile warning | Prunes downstream dependents without aborting the run | | `StackTrail` | A breadcrumb trail | Every issue's location is a trail's `toString` | ## SKMTC vocabulary — load-bearing terms [#skmtc-vocabulary--load-bearing-terms] Every term in this list maps to a specific construct in `@skmtc/core`'s exported surface. When writing about SKMTC, prefer these terms. Terms that don't appear here (and aren't in the alphabetized entries below) likely don't have a referent in the code. | Category | Terms | | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | | **Pipeline phases** | Parse, Generate, Render — the three phases `CoreContext` runs in order | | **Primitive methods on `GenerateContext`** | `register`, `insertOperation`, `insertModel`, `insertNormalizedModel`, `defineAndRegister`, `findDefinition` | | **DSL nouns** | `File`, `Definition`, `Identifier`, `Snippet`, `Projection`, `Inserted`, `ContentSettings`, `Stringable` | | **Static-method contracts on projection classes** | `toIdentifierName`, `toIdentifierType`, `toExportPath`, `toEnrichments`, `isSupported` | | **Driver orchestration classes** | `OasOperationDriver`, `GqlOperationDriver`, `ModelDriver` | *** ## A [#a] ### `affirmDefinition` [#affirmdefinition] The Driver-side integrity check on every cache hit: the cached `Definition`'s `generatorKey` must match the caller's, else it throws "Registered definition mismatch". See [files-and-dedup](/docs/concepts/files-and-dedup#the-integrity-layer-affirmdefinition--generatorkey). ### Agent-native operation modes [#agent-native-operation-modes] The three modes every state-touching CLI command supports: interactive (TTY + Ink UI), strict text (non-TTY plain stdout), and strict JSON (`--json` flag). See [CLI overview](/docs/reference/cli/overview). ## B [#b] ### basePath [#basepath] The `settings.basePath` field in `client.json`: both the on-disk root for generated files and the bundler `@` alias root in the consuming app. See [projects-and-workspaces](/docs/concepts/projects-and-workspaces#basepath-alignment-with-the-consuming-app). ### Bundle [#bundle] `bundle.js` — the compiled JS file the SKMTC Worker loads, produced by `deno bundle worker.ts -o bundle.js`. See [the-worker-runtime](/docs/concepts/the-worker-runtime). ### Bundle freshness [#bundle-freshness] The invariant that `bundle.js` matches the current `deno.json#imports`. Drift triggers a refuse-with-recipe error in strict-mode `generate`; the `skmtc doctor` check `project-bundle/` surfaces stale bundles. ## C [#c] ### Cache key [#cache-key] The `(identifier.name, exportPath)` pair that looks up a `Definition` in `File.definitions`; decides *whether* to reuse, while the [Generator key](#generator-key) decides *that* reuse is safe. See [files-and-dedup](/docs/concepts/files-and-dedup#cache-key-vs-integrity-key). ### Capability gate [#capability-gate] A generator's `isSupported({ operation })` predicate deciding whether it handles a given operation/model; `false` yields a `notSupported` manifest outcome. See [anatomy of a generator](/docs/authoring/anatomy-of-a-generator). ### Cascade pruning [#cascade-pruning] The `removeErroredItems` mechanism that prunes consumers of a failed `$ref` from the parsed document, one hop deep. See [error-handling-philosophy](/docs/explanation/error-handling-philosophy#tier-2-cross-ref-via-removeerroreditems). ### clone-to-customize [#clone-to-customize] The design philosophy: stock generators ship hardcoded values that mark customization seams; users `skmtc clone` the generator and edit the source. See [clone-vs-install](/docs/concepts/clone-vs-install). ### `ContentSettings` [#contentsettings] The `settings` instance property on Projection classes, computed by the Driver from the Projection's static methods; carries `identifier`, `exportPath`, and `enrichments` for the current item. ### CustomValue [#customvalue] An escape-hatch Snippet wrapping an arbitrary TypeScript fragment not expressible through the OAS-derived schema model; the `type: 'custom'` branch of [`schemaToValueFn`](#schematovaluefn) dispatch. See [the CustomValue reference](/docs/reference/api/dsl-custom-value). ## D [#d] ### Definition [#definition] The `export const NAME = VALUE;` (or `export type NAME = …;`) wrapper around a Projection's output value, created by Drivers and carrying the `generatorKey` that feeds [`affirmDefinition`](#affirmdefinition). See [files-and-dedup](/docs/concepts/files-and-dedup). ### Deduplication [#deduplication] The behavior of `register` calls on the same `File`: `imports` dedup via `Set.add`, `definitions` via `Map.has` first-write-wins, `reExports` per module-and-entity-type. See [files-and-dedup](/docs/concepts/files-and-dedup#the-dedup-rules). ### `destinationPath` [#destinationpath] The file path a Snippet's imports or child definitions register against — the file being registered *into* right now, as opposed to [`exportPath`](#exportpath). See [stringable-composition](/docs/concepts/stringable-composition#exportpath-vs-destinationpath). ### Driver [#driver] The orchestrator class for inserting a Projection (`OasOperationDriver`, `GqlOperationDriver`, `ModelDriver`): computes settings, performs the cache lookup, instantiates on miss or affirms on hit, registers the `Definition`. See [files-and-dedup §What Drivers do](/docs/concepts/files-and-dedup#what-drivers-do--in-one-sentence-each). ## E [#e] ### Eject / adopt [#eject--adopt] Taking ownership of a generated file (`eject`: rename to drop the generated suffix, record in `settings.ejected`, generators stop writing it) and returning it to generation (`adopt`). See [eject](/docs/reference/cli/eject) and [adopt](/docs/reference/cli/adopt). ### Enrichment [#enrichment] User-supplied per-operation or per-model configuration declared in `client.json` and validated against the generator's Valibot schema from `toEnrichmentSchema`. See [enrichments](/docs/concepts/enrichments). ### `EnrichmentRequest` [#enrichmentrequest] A generator-initiated request (`{ prompt, enrichmentSchema, content }`) for an LLM-fillable enrichment, returned by the optional `toEnrichmentRequest(refName)`. See [enrichments §AI-driven enrichments](/docs/authoring/how-to/add-enrichment-options#ai-driven-enrichments--enrichmentrequest). ### Entity type (`TsIdentifier.type`) [#entity-type-tsidentifiertype] The per-language declaration discriminant on a language package's identifier subclass — TypeScript's vocabulary is `'variable' | 'type' | 'class' | 'interface' | 'namespace'`. See [stringable-composition](/docs/concepts/stringable-composition#identifier-and-entity-kinds). ### `exportPath` [#exportpath] The file path where a Projection's `Definition` lives, returned by the static `toExportPath`; contrast [`destinationPath`](#destinationpath). See [stringable-composition](/docs/concepts/stringable-composition#exportpath-vs-destinationpath). ## F [#f] ### `fallbackName` [#fallbackname] The name a Projection uses when the schema being normalized isn't a named `$ref`; passed to `insertNormalizedModel` for inline schemas. See [cross-generator-coordination](/docs/concepts/cross-generator-coordination). ### File (DSL class) [#file-dsl-class] The in-memory representation of a generated file: three maps (`imports`, `reExports`, `definitions`), each with its own dedup rule; serialized by Render via `file.toString()`. See [files-and-dedup](/docs/concepts/files-and-dedup). ## G [#g] ### Gen-map (anchors) [#gen-map-anchors] The attribution sidecar an opted-in run writes next to each generated file, mapping byte ranges of output back to the generator, schema location, and variant that produced them. Toggled by `client.json#settings.anchors.enabled` or `--anchors` / `--no-anchors` on [generate](/docs/reference/cli/generate). ### Generator [#generator] A JSR package (or local TypeScript directory) implementing the generator protocol: exports an entry function via `toOasOperationEntry`, `toGqlOperationEntry`, or `toModelEntry`. See [generators-as-packages](/docs/concepts/generators-as-packages). ### Generator key [#generator-key] A branded composite identifier on every `Definition` — four shapes (OAS operation, GQL operation, model, generator-only) — used by [`affirmDefinition`](#affirmdefinition) to detect cache-hit collisions. See [files-and-dedup](/docs/concepts/files-and-dedup#the-generator-key-shapes). ### Global state [#global-state] `~/.skmtc/` — auth token, shadow project state, schema caches. Lives outside any project; check it when local state alone doesn't explain a failure. ## H [#h] ### Hub (skmtc-hub) [#hub-skmtc-hub] The hosted service behind `login`, `publish`, `push`, and `pull`: accounts (users or orgs) own published stacks and the projects that run them. See [what-is-skmtc-hub](/docs/explanation/what-is-skmtc-hub). ## I [#i] ### `Identifier` [#identifier] Neutral naming data (name + opaque per-language `kind` + `exported` + `typeName`), created via the language package's `createVariable` / `createType` factories. See [stringable-composition](/docs/concepts/stringable-composition#identifier-and-entity-kinds). ### `include` / `skip` filters [#include--skip-filters] `client.json#settings.include` and `.skip` — operation/model allow-lists and deny-lists; filter order is `isSupported` → `include` → `skip`. See [skip or include operations](/docs/using/how-to/skip-or-include-operations). ### `insertModel` [#insertmodel] The `GenerateContext` method that inserts a model Projection via `ModelDriver` and returns an [`Inserted`](#inserted). See [how-generators-produce-output](/docs/concepts/how-generators-produce-output#contextinsertoperation-projection-operation--and-contextinsertmodelmyprojection-refname). ### `insertNormalizedModel` [#insertnormalizedmodel] The `GenerateContext` method for inserting a Projection from an *inline* schema (no `$ref`); calls the projection's [`schemaToValueFn`](#schematovaluefn) and registers the result under `fallbackName`. See [the-type-system](/docs/concepts/the-type-system#where-schematovaluefn-is-called-from). ### `insertOperation` [#insertoperation] The `GenerateContext` method for inserting an operation Projection (OAS or GraphQL) via the appropriate Driver; returns an [`Inserted`](#inserted). See [how-generators-produce-output](/docs/concepts/how-generators-produce-output#contextinsertoperation-projection-operation--and-contextinsertmodelmyprojection-refname). ### `Inserted` [#inserted] The return type of `insertOperation` and `insertModel`: carries the peer Projection's `ContentSettings`, its `Definition`, and helpers like `.toName()`. See [cross-generator-coordination](/docs/concepts/cross-generator-coordination). ### Integrity key [#integrity-key] Synonym for [Generator key](#generator-key) in contexts contrasting it with the [Cache key](#cache-key). ### `isSupported` [#issupported] A generator's capability-gate predicate. See [Capability gate](#capability-gate). ## J [#j] ### `JsonFile` [#jsonfile] Sibling to [`File`](#file-dsl-class) for JSON output: one `content` field, serialized with `JSON.stringify`, last-write-wins on conflicts. See [files-and-dedup §JsonFile](/docs/concepts/files-and-dedup#jsonfile--the-sibling-for-json-output). ## L [#l] ### Lenient input, strict diagnostics [#lenient-input-strict-diagnostics] The error-handling philosophy: parse fails open (one bad item doesn't kill the run), but every dropped item and type inference is logged as a `ParseIssue`. See [error-handling-philosophy](/docs/explanation/error-handling-philosophy). ### `List` [#list] The typed list-builder utility in `@skmtc/lang-typescript` (`ListObject`, `ListArray`, `ListParams`, `ListLines`, plus record and key-value helpers). See [stringable-composition §The List builder](/docs/concepts/stringable-composition#the-list-builder). ## M [#m] ### Manifest [#manifest] `manifest.json` — the canonical record of every generation run, written to `.skmtc//.settings/manifest.json` and overwritten per run. See [the-manifest](/docs/concepts/the-manifest) and the [manifest-format reference](/docs/reference/manifest-format). ### `MAX_LOOKUPS` [#max_lookups] The constant `10` in `OasRef` limiting `$ref` chain resolution depth; exceedance throws "Max lookups reached", catching cycles and pathologically deep chains. ### `modelDepth` [#modeldepth] The per-`(generatorId, refName)` counter on `GenerateContext` that detects self-referential schemas at generate time, letting a `Ref` Snippet render a deferred form instead of recursing. See [the-type-system §Handling recursive types](/docs/concepts/the-type-system#handling-recursive-types--the-modeldepth-counter). ### `Modifiers` [#modifiers] The `{ required?, nullable?, description? }` triple on every `TypeSystemValue`; polarity is `required`, not `optional`. See [the-type-system §Modifiers](/docs/concepts/the-type-system#modifiers--required-not-optional). ## O [#o] ### `OasRef` [#oasref] The class representing an OpenAPI `$ref`; constructed during parse with a live reference to the in-progress document, resolves lazily. See [refs-and-resolution](/docs/concepts/refs-and-resolution). ### `OasSchema` [#oasschema] The discriminated union of schema variant classes (`OasObject`, `OasArray`, `OasUnion`, the scalar variants, `OasUnknown`) — sibling classes with a `.type` discriminator, not a class hierarchy. ### `oasType` [#oastype] The runtime tag on parsed OAS items (`'schema'`, `'parameter'`, `'response'`, etc.), used by `OasRef.resolveOnce` for the type-integrity check. ## P [#p] ### Parse phase [#parse-phase] The first engine phase — converts `SkmtcDocumentInput` to `SkmtcParsedDocument` under lenient input, strict diagnostics. See [the-three-phases](/docs/concepts/the-three-phases). ### `ParseContext` [#parsecontext] The Parse-phase context class: parser state, the issue list, and the cascade-pruning maps. See [the ParseContext reference](/docs/reference/api/parse-context). ### `ParseIssue` [#parseissue] A structured diagnostic entry produced during parse. See [error-codes](/docs/reference/error-codes) and the [manifest format](/docs/reference/manifest-format). ### Peer-pin check [#peer-pin-check] The pre-flight verification on `skmtc clone` that the cloned generator's `@skmtc/core` version matches the project's pin; override with `--force`. ### Preview (manifest) [#preview-manifest] A manifest entry pairing a `PreviewModule` with a source descriptor, produced by a generator's optional `toPreviewModule` hook for UI / IDE tooling. See [the-manifest](/docs/concepts/the-manifest#previews--for-tooling). ### Projection [#projection] A named, file-level generated artifact, wrapped in `Definition` and cached by `(identifier.name, exportPath)`; pull-based — instantiated only when an `insert*` call asks for it. See [projections-and-snippets](/docs/concepts/projections-and-snippets). ## R [#r] ### Recipe error [#recipe-error] A structured error from strict-mode CLI commands when a required argument is missing: Usage, Example, and a Discover line pointing at the follow-up command. Exit code 2. ### refConsumers [#refconsumers] `ParseContext.#refConsumers` — a map recording every `$ref` encounter, used during cascade pruning to identify consumers of a failed schema. See [the StackTrail reference](/docs/reference/api/stack-trail). ### refErrors [#referrors] `ParseContext.#refErrors` — errors keyed by the `$ref` they invalidated, used during cascade pruning. See [the StackTrail reference](/docs/reference/api/stack-trail). ### `register` [#register] The lowest-level registration method on `GenerateContext`, mutating the file map at `destinationPath`; the only legitimate way to add imports. See [how-generators-produce-output §register](/docs/concepts/how-generators-produce-output#contextregister-destinationpath-imports-definitions-reexports-). ### "Registered definition mismatch" [#registered-definition-mismatch] The runtime error thrown by [`affirmDefinition`](#affirmdefinition) when two different generators land on the same cache key. See [files-and-dedup §Reading a mismatch error](/docs/concepts/files-and-dedup#reading-a-registered-definition-mismatch-error). ### Remote-only project [#remote-only-project] A SKMTC project whose `deno.json#imports` contains only JSR-installed generators (no local clones); bundles and generates like any other project. ### Render phase [#render-phase] The third engine phase — serializes the file map to `{ path: content }` artifacts; pure serialization, no formatter. See [the-three-phases](/docs/concepts/the-three-phases). ### `RenderContext` [#rendercontext] The Render-phase context class: a thin wrapper around file iteration and `file.toString()`. Does not format output. ### `ResultsHandler` [#resultshandler] The log handler that converts `logger.warn` / `logger.error` calls into manifest `results` leaves — a generator that logs an error contributes to the results tree without throwing. See [the-manifest §results](/docs/concepts/the-manifest#results--what-happened-per-generator-item-pair). ### `ResultType` [#resulttype] The leaf-value type in the manifest's `results` tree (`'success' | 'warning' | 'error' | 'skipped' | 'notSupported'`); `'success'` does not guarantee output — check `files`. See [manifest-format](/docs/reference/manifest-format#results). ## S [#s] ### Sandbox API [#sandbox-api] A hosted-execution alternative to the local Worker: the host posts the schema to a remote SKMTC service, which runs the engine and returns artifacts + manifest. Authenticated via a stored token. ### Schema source [#schema-source] The OAS or GraphQL document SKMTC generates from — positional on `skmtc generate ` or pinned in `client.json#source`. ### `schemaToValueFn` [#schematovaluefn] The static dispatch every `ModelProjection` class exposes: receives a schema-plus-context bag and returns a structurally matching [`TypeSystemValue`](#typesystemvalue). See [the-type-system](/docs/concepts/the-type-system). ### `SkmtcDocumentInput` [#skmtcdocumentinput] A discriminated union — `{ type: 'oas', value }` or `{ type: 'gql', value }` — that the Worker receives on the `GENERATE` message. ### `SkmtcParsedDocument` [#skmtcparseddocument] The parsed counterpart to `SkmtcDocumentInput`: `{ type: 'oas', value: OasDocument }` or `{ type: 'gql', value: GqlDocument }`. ### Snippet [#snippet] An anonymous, embeddable generated fragment: no `settings`, no `exportPath`, no cache participation; embedded via template-literal interpolation. See [projections-and-snippets](/docs/concepts/projections-and-snippets). ### `SnippetBase` [#snippetbase] The root class for all DSL elements — provides `context`, `generatorKey`, and `register()`; both Projections and Snippets extend it. ### Stack (hub) [#stack-hub] A published, immutable version of a SKMTC project on the hub — identity `deno.json#name` (`@account/slug`), addressed by semver. Produced by [publish](/docs/reference/cli/publish); hub projects pin one. ### `StackTrail` [#stacktrail] The mutable stack of string frames threaded through Parse that tracks the walker's position; stringifies as a colon-separated path. See [the StackTrail reference](/docs/reference/api/stack-trail). ### Strict mode [#strict-mode] CLI behavior when `--no-input` is passed (or stdout is non-TTY): no Ink UI, no prompts, required arguments up front; failures produce recipe errors on stderr. ### Stringable [#stringable] The structural type for anything with a `toString(): string` method — the DSL's composition mechanism via template-literal interpolation. See [stringable-composition](/docs/concepts/stringable-composition). ### `synthesizeArgsObject` [#synthesizeargsobject] Core helper that turns a `GqlOperation`'s typed argument list into an `OasObject` schema; returns `undefined` for argument-less operations. See [the-graphql-pipeline §synthesizeArgsObject](/docs/concepts/the-graphql-pipeline#synthesizeargsobject--turning-arguments-into-a-schema). ## T [#t] ### `transform` [#transform] The per-item hook in a generator's `mod.ts` entry, called once per matched `(operation | model, variant)`; returns `void` — output happens via side effects (`register`, `insert*`). See [how-generators-produce-output](/docs/concepts/how-generators-produce-output#why-transform-returns-nothing). ### `tryParseAt` [#tryparseat] The per-item parse-isolation helper: runs a parser callback inside a `stackTrail.trace`, catches throws, logs an error issue, and returns `undefined` so the entry is omitted. See [error-handling-philosophy §Tier 1](/docs/explanation/error-handling-philosophy#tier-1-per-item-isolation-via-tryparseat). ### `TypeSystemValue` [#typesystemvalue] The discriminated-union intermediate representation a model generator produces from an `OasSchema` — twelve structural variants, each carrying [`Modifiers`](#modifiers). See [the-type-system](/docs/concepts/the-type-system). ## V [#v] ### Variant [#variant] A named axis below `(operation, method)` / `(rootKind, fieldName)` / `refName` along which one source item produces *N* Definitions instead of one (section-edit forms, wizard steps, mock scenarios). Defaults to `'main'`. See [variants](/docs/concepts/variants). ### `verbatimModuleSyntax` [#verbatimmodulesyntax] The TypeScript compiler option requiring `import { type X }` for type-only imports; SKMTC's `Identifier` tracks entity types to render correct imports under it. ## W [#w] ### Webhook [#webhook] The OpenAPI 3.1 subject for server-initiated calls: structurally an Operation Object keyed by **name** rather than URL path, with inverted request/response semantics — a distinct subject (`OasWebhook`), never routed through an operation generator. See [webhook generators](/docs/reference/api/webhook-generators). ### Worker [#worker] The sandboxed Deno Worker thread that runs the engine, one-shot per generate run. See [the-worker-runtime](/docs/concepts/the-worker-runtime). ### `worker.ts` [#workerts] A derived file in `.skmtc//worker.ts`, templated from `deno.json#imports` by `skmtc bundle`; regenerated, not hand-edited. ## Cross-references [#cross-references] * [The three phases](/docs/concepts/the-three-phases) — fuller treatment of most terms here * [Manifest format](/docs/reference/manifest-format) * [Error codes](/docs/reference/error-codes)