@thymian/plugin-sampler 0.3.0-canary.20261007-e6cb8dc → 0.3.0-canary.20261007-cdbe1d3

package/dist/generation/types/declaration-set.js

@@ -0,0 +1,389 @@
+/**
+ * The set of declarations the type surface emits, with one copy of each.
+ *
+ * `json-schema-to-typescript` compiles one schema at a time and each call
+ * returns a self-contained unit: the root declaration plus every named
+ * component it references. Two transactions that both reference `Astronaut`
+ * therefore arrive carrying their own copy of it — nine copies of it, on the
+ * demo description, and nine copies of `AstronautInput` and `LaunchInput`
+ * beside them.
+ *
+ * That is not merely noisy. It compiles only for as long as every duplicated
+ * component happens to be an `interface`, because identical interfaces merge; a
+ * component that compiles to a type ALIAS — an enum, a union, an array — is
+ * `TS2300: Duplicate identifier` the moment a second transaction references it.
+ * And the drift gate cannot see either, because it compiles hooks with
+ * `skipLibCheck: true`, which is exactly the flag that stops TypeScript from
+ * reporting errors inside a `.d.ts`.
+ *
+ * De-duplicating also keeps the committed diff proportionate: editing one
+ * component used to move as many lines as there are transactions using it.
+ */
+import { createHash } from 'node:crypto';
+import ts from 'typescript';
+const DECLARATION_LINE = /^export (?:interface|type) ([A-Za-z0-9_$]+)/;
+/**
+ * Splits one `compile()` result into its top-level declarations.
+ *
+ * Safe on the emitter's output rather than on TypeScript in general: every
+ * top-level declaration begins at column zero and everything nested is
+ * indented, so a column-zero `export` line — or the `/**` opening the JSDoc
+ * block that belongs to it — is a boundary.
+ */
+export function splitDeclarations(source) {
+    const lines = source.split('\n');
+    const starts = [];
+    lines.forEach((line, index) => {
+        if (line === '/**') {
+            starts.push(index);
+            return;
+        }
+        // A JSDoc block immediately above a declaration is part of it, so the
+        // comment already opened this chunk.
+        if (DECLARATION_LINE.test(line) && lines[index - 1]?.trim() !== '*/') {
+            starts.push(index);
+        }
+    });
+    return starts.map((start, position) => {
+        const end = starts[position + 1] ?? lines.length;
+        const text = lines.slice(start, end).join('\n').trimEnd();
+        const declared = text
+            .split('\n')
+            .map((line) => DECLARATION_LINE.exec(line)?.[1])
+            .find((name) => name !== undefined);
+        if (declared === undefined) {
+            throw new Error(`The type generator produced a declaration it cannot name:\n${text}`);
+        }
+        return { name: declared, text };
+    });
+}
+/**
+ * Every identifier in `text` that sits in a renameable position, whatever it
+ * refers to.
+ *
+ * The same AST walk {@link renameReferences} edits by, asking which names a
+ * declaration mentions rather than rewriting them. Deliberately NOT filtered
+ * by a unit's member names: the result then depends on the text alone, which
+ * is what lets {@link DeclarationSet} memoize it by text and parse each
+ * distinct declaration once per process rather than once per unit it recurs
+ * in.
+ */
+function renameableIdentifiers(text) {
+    const source = ts.createSourceFile('declaration.d.ts', text, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TS);
+    const found = new Set();
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && isRenameablePosition(node)) {
+            found.add(node.text);
+        }
+        ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(source, visit);
+    return [...found];
+}
+/**
+ * What makes one declaration the same *variant* as another: its own text plus
+ * the text of everything it transitively references inside its unit.
+ *
+ * The raw text alone is not enough, because a declaration's references are
+ * resolved per unit. Two sources declaring `User = { address: Address }`
+ * byte-identically are the same text and **not** the same type when their
+ * `Address` differs — reusing the first source's alias for the second gave the
+ * second source a committed type describing the first source's API, with its
+ * own renamed `Address_2` emitted and never referenced. `checkSurface` stayed
+ * clean because the surface was internally consistent; it was just wrong.
+ *
+ * One key per member of the unit, computed from one adjacency map. The first
+ * version of this re-parsed every reachable declaration once per member, so a
+ * unit of *n* declarations cost O(n × reach) parses — a chain of 200 was
+ * 20,100 — and it paid that on every unit, conflict or not, per
+ * `generateTypeSurface`, which is per `init`, `sync` and `validate`. The
+ * parse is the only expensive step, so it happens at most once per member
+ * here and, through `references`, at most once per distinct text; deriving
+ * each closure is then a walk over a map.
+ *
+ * The key is a digest rather than the closure's text: `resolved` keeps one
+ * key per variant for the life of the set, and the text of a root's whole
+ * unit is the wrong thing to hold that many times.
+ */
+function variantKeys(unit, references) {
+    const texts = new Map(unit.map((member) => [member.name, member.text]));
+    const adjacency = new Map(unit.map((member) => [
+        member.name,
+        references(member.text).filter((name) => texts.has(name)),
+    ]));
+    const keys = new Map();
+    for (const member of unit) {
+        const closure = new Set();
+        const pending = [member.name];
+        while (pending.length > 0) {
+            const name = pending.pop();
+            if (closure.has(name)) {
+                continue;
+            }
+            closure.add(name);
+            pending.push(...(adjacency.get(name) ?? []));
+        }
+        const hash = createHash('sha1');
+        for (const name of [...closure].sort()) {
+            hash
+                .update(name)
+                .update('\u0000')
+                .update(texts.get(name));
+            hash.update('\u0001');
+        }
+        keys.set(member.name, hash.digest('hex'));
+    }
+    return keys;
+}
+/**
+ * Whether `identifier` sits in a position a rename may touch: either it NAMES
+ * a top-level declaration this set controls, or it REFERS to one.
+ *
+ * Enumerated rather than inferred, because the alternative ("anything that
+ * isn't a property-name or string-literal position") is exactly the
+ * reasoning that let a text-level regex rename an identifier-shaped property
+ * key: `status: string` and `status: Status` are indistinguishable to a
+ * lexical match, but `ts.isPropertySignature(parent) && parent.name ===
+ * identifier` is false for the first and irrelevant to the second, because
+ * the second's `Status` is the type annotation, not the name.
+ *
+ * Naming positions — where a declaration's OWN name lives, which a rename
+ * must also rewrite so the definition and its references stay one string:
+ * - `InterfaceDeclaration.name`, `TypeAliasDeclaration.name`.
+ *
+ * Reference positions:
+ * - `TypeReferenceNode.typeName` — `Status`, `Array<Status>`, `Status[]` (an
+ *   `ArrayTypeNode` wrapping a `TypeReferenceNode`).
+ * - `ExpressionWithTypeArguments.expression` — `interface X extends Status`,
+ *   the shape `allOf` composition emits.
+ * - `TypeQueryNode.exprName` — `typeof Status`.
+ *
+ * A qualified name (`Foo.Status`) never reaches here as an `Identifier`: its
+ * `typeName`/`exprName` is a `QualifiedName`, which this function does not
+ * match, so a dotted reference is correctly left alone — none of the emitter's
+ * own declarations are namespaced.
+ */
+function isRenameablePosition(identifier) {
+    const parent = identifier.parent;
+    if (!parent) {
+        return false;
+    }
+    if (ts.isInterfaceDeclaration(parent) || ts.isTypeAliasDeclaration(parent)) {
+        return parent.name === identifier;
+    }
+    if (ts.isTypeReferenceNode(parent)) {
+        return parent.typeName === identifier;
+    }
+    if (ts.isExpressionWithTypeArguments(parent)) {
+        return parent.expression === identifier;
+    }
+    if (ts.isTypeQueryNode(parent)) {
+        return parent.exprName === identifier;
+    }
+    return false;
+}
+/**
+ * Rewrites a unit's own declaration names and every reference to them.
+ *
+ * Scoped to one compiled unit, where an identifier can only mean that unit's
+ * own declaration. Parses `text` with the TypeScript API and edits only the
+ * identifiers {@link isRenameablePosition} approves — never a property name
+ * (identifier-shaped or not), never the contents of a string literal, and
+ * never a comment, because none of those are nodes the parser hands to a
+ * visitor at all. The edits are applied as raw text splices at the
+ * identifiers' own positions, back to front, so everything else — formatting,
+ * comments, unrelated text — survives byte-for-byte.
+ */
+function renameReferences(text, renames) {
+    if (renames.size === 0) {
+        return text;
+    }
+    const source = ts.createSourceFile('declaration.d.ts', text, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TS);
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && isRenameablePosition(node)) {
+            const replacement = renames.get(node.text);
+            if (replacement !== undefined) {
+                edits.push({
+                    start: node.getStart(source),
+                    end: node.getEnd(),
+                    replacement,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    let result = text;
+    // Back to front, so an earlier edit's offsets never shift a later one's.
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+        result =
+            result.slice(0, edit.start) + edit.replacement + result.slice(edit.end);
+    }
+    return result;
+}
+export class DeclarationSet {
+    byName = new Map();
+    /**
+     * Every name that may not be handed to a new declaration as-is: every name
+     * already committed to {@link byName}, plus the {@link reserved} fixed
+     * roots the caller seeds the set with. A name can be in here without being
+     * in `byName` — a reserved root nothing has collided with yet — which is
+     * exactly what makes a reservation free to check and free of output: {@link
+     * all} only ever reads `byName`.
+     */
+    used;
+    /**
+     * For each ORIGINAL declaration name, the raw (pre-rename) text of every
+     * variant this set has already resolved a final name for — whether that
+     * final name is the bare name itself (the non-conflict branch) or a
+     * renamed alias (the conflict branch).
+     *
+     * What makes this safe to reuse across separate `add()` calls: two
+     * declarations that share both a name and byte-identical text are the same
+     * declaration by this set's own definition of "conflict" (`text !==
+     * text`), so pointing a later occurrence at an earlier resolution is never
+     * a merge of two DIFFERENT things — only ever the same thing recognized
+     * twice. Keyed by the RAW text (before this call's renames are applied),
+     * because every occurrence of, say, a `Status`-named component carries that
+     * same raw form regardless of which final name it ends up resolving to —
+     * that is the one constant a repeat occurrence can be recognized by.
+     *
+     * Without this, a component that conflicts with a fixed root — or with
+     * another document's differently-bodied same-named component — mints a
+     * FRESH suffix every single time it recurs (`Status_2`, `Status_3`, …one
+     * per referencing transaction), because the conflict branch used to treat
+     * every conflicting unit as unprecedented. That defeats the set's own
+     * purpose: "one declaration per component" is exactly the guarantee this
+     * index restores for the conflict branch, matching what the non-conflict
+     * branch already gives for free.
+     */
+    resolved = new Map();
+    /**
+     * The renameable identifiers of every declaration text this set has seen,
+     * so a component that recurs in forty units — the demo description's
+     * shape — is parsed once, not forty times.
+     */
+    identifiersByText = new Map();
+    /**
+     * @param reserved the fixed root names {@link NameRegistry} mints around
+     * the generated declarations — `Status`, `Method`, `Endpoints` and the
+     * rest. A component whose OWN name collides with one of these can never be
+     * merged into it (they are never the same declaration), so a reservation
+     * has to force the conflict branch even though nothing with that name has
+     * been committed yet. Sharing the exact list `NameRegistry` was
+     * constructed with is what keeps the two reservations from drifting apart.
+     */
+    constructor(reserved = []) {
+        this.used = new Set(reserved);
+    }
+    /** Records that `originalName`/`variant` resolved to `finalName`, and commits `finalName`/`finalText` as held. */
+    commit(finalName, finalText, originalName, variant) {
+        this.byName.set(finalName, finalText);
+        this.used.add(finalName);
+        let variants = this.resolved.get(originalName);
+        if (!variants) {
+            variants = new Map();
+            this.resolved.set(originalName, variants);
+        }
+        variants.set(variant, finalName);
+    }
+    /**
+     * Adds one compiled unit and returns the name its root ended up with.
+     *
+     * A unit whose declarations are all either new or byte-identical to what is
+     * already held is merged into it, which is the case every single-document
+     * description produces: one `$defs` name is one schema, so every copy of
+     * `Astronaut` is the same `Astronaut`.
+     *
+     * A unit that genuinely conflicts is given fresh names for **all** of its
+     * declarations rather than only the conflicting ones. Renaming part of a
+     * unit would leave the rest sharing declarations with whichever unit got
+     * there first, and "this component is the one my own root was compiled
+     * against" is the property worth keeping. Two shapes reach this branch:
+     * same component name, different body — which two separate description
+     * files can both declare — and a component named after one of the fixed
+     * roots this set was seeded with, which is a conflict on sight because a
+     * user's component and the surface's own `Status` are never the same
+     * declaration.
+     *
+     * "Fresh" does not mean "unconditionally new", though: {@link resolved}
+     * recognizes a (name, text) pair this set has already renamed once and
+     * reuses that name rather than minting another alias for it, so a
+     * component that conflicts with a fixed root — or with another document's
+     * component of the same name — is still deduplicated across every site
+     * that declares it identically, exactly as a non-conflicting component
+     * already is.
+     */
+    add(unit, rootName) {
+        if (unit.length === 0) {
+            return rootName;
+        }
+        const conflicts = unit.some((declaration) => {
+            if (!this.used.has(declaration.name)) {
+                return false;
+            }
+            return this.byName.get(declaration.name) !== declaration.text;
+        });
+        // One key per member, computed before anything is committed: a variant is
+        // the declaration *and its references' contents*, so the key cannot be
+        // derived after a rename has already been chosen.
+        const keys = variantKeys(unit, (text) => this.identifiersOf(text));
+        if (!conflicts) {
+            for (const declaration of unit) {
+                this.commit(declaration.name, declaration.text, declaration.name, keys.get(declaration.name));
+            }
+            return rootName;
+        }
+        const renames = new Map();
+        for (const declaration of unit) {
+            // A variant this set already resolved — same text *and* the same
+            // references resolving to the same contents — so reuse its alias rather
+            // than minting another for the same type.
+            const reused = this.resolved
+                .get(declaration.name)
+                ?.get(keys.get(declaration.name));
+            renames.set(declaration.name, reused ?? this.freeName(declaration.name));
+        }
+        for (const declaration of unit) {
+            const name = renames.get(declaration.name);
+            // Already resolved by an earlier `add()` call: its text is already
+            // correct, and re-deriving it here would just repeat that work.
+            if (this.byName.has(name)) {
+                continue;
+            }
+            this.commit(name, renameReferences(declaration.text, renames), declaration.name, keys.get(declaration.name));
+        }
+        return renames.get(rootName) ?? rootName;
+    }
+    /** Every declaration held, in name order. */
+    all() {
+        return [...this.byName.keys()].sort().map((name) => {
+            return this.byName.get(name);
+        });
+    }
+    identifiersOf(text) {
+        let identifiers = this.identifiersByText.get(text);
+        if (identifiers === undefined) {
+            identifiers = renameableIdentifiers(text);
+            this.identifiersByText.set(text, identifiers);
+        }
+        return identifiers;
+    }
+    freeName(candidate) {
+        let name = candidate;
+        let suffix = 1;
+        while (this.used.has(name)) {
+            suffix += 1;
+            name = `${candidate}_${suffix}`;
+        }
+        // Claimed immediately: the caller assigns every name in a unit before it
+        // writes any of them, so two members of one unit must not pick the same
+        // free name.
+        this.used.add(name);
+        return name;
+    }
+}
+//# sourceMappingURL=declaration-set.js.map

package/dist/generation/types/declaration-set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration-set.js","sourceRoot":"","sources":["../../../src/generation/types/declaration-set.ts"],"names":[],"mappings":"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"}

package/dist/generation/types/example-reflection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Reflects a schema's `examples` into the types its properties get.
+ *
+ * **Property-level only.** An example value pushes down into the property (or
+ * array element type) it belongs to, recursively, and a primitive property with
+ * examples becomes `'A' | 'B' | (base & {})` — the literals autocomplete while
+ * the type stays open.
+ *
+ * An object body is **never** emitted as a union of example-shaped object types,
+ * and that is not a stylistic preference. Hooks mutate the request in place, and
+ * on a union TypeScript checks a property *write* against the intersection of
+ * the members' property types and rejects any property missing from a member —
+ * so a union of closed example objects turns ordinary mutation into a compile
+ * error. That is exactly the flaw the earlier attempt shipped.
+ *
+ * The mechanism is `json-schema-to-typescript`'s `tsType` keyword: the schema is
+ * annotated and the emitter prints the annotation verbatim, so nothing here has
+ * to know how a schema becomes a type.
+ */
+export declare function reflectExamples(schema: unknown): unknown;
+//# sourceMappingURL=example-reflection.d.ts.map

package/dist/generation/types/example-reflection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-reflection.d.ts","sourceRoot":"","sources":["../../../src/generation/types/example-reflection.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAExD"}

package/dist/generation/types/example-reflection.js

@@ -0,0 +1,135 @@
+import { isRecord } from '@thymian/core';
+/**
+ * Reflects a schema's `examples` into the types its properties get.
+ *
+ * **Property-level only.** An example value pushes down into the property (or
+ * array element type) it belongs to, recursively, and a primitive property with
+ * examples becomes `'A' | 'B' | (base & {})` — the literals autocomplete while
+ * the type stays open.
+ *
+ * An object body is **never** emitted as a union of example-shaped object types,
+ * and that is not a stylistic preference. Hooks mutate the request in place, and
+ * on a union TypeScript checks a property *write* against the intersection of
+ * the members' property types and rejects any property missing from a member —
+ * so a union of closed example objects turns ordinary mutation into a compile
+ * error. That is exactly the flaw the earlier attempt shipped.
+ *
+ * The mechanism is `json-schema-to-typescript`'s `tsType` keyword: the schema is
+ * annotated and the emitter prints the annotation verbatim, so nothing here has
+ * to know how a schema becomes a type.
+ */
+export function reflectExamples(schema) {
+    return annotate(schema, []);
+}
+/** Keywords whose branches describe the same value as the node holding them. */
+const COMPOSITION_KEYWORDS = ['allOf', 'anyOf', 'oneOf'];
+/**
+ * Where named component schemas live. `$defs` is the 2020-12 spelling and
+ * `definitions` the draft-07 one; both are handled because the rename to
+ * `definitions` happens elsewhere and this walk must not depend on the order.
+ */
+const DEFINITION_KEYWORDS = ['$defs', 'definitions'];
+/** The examples a schema node declares, in the order it declared them. */
+function examplesOf(node) {
+    const fromPlural = Array.isArray(node['examples']) ? node['examples'] : [];
+    const fromSingular = 'example' in node ? [node['example']] : [];
+    return [...fromPlural, ...fromSingular];
+}
+function annotate(schema, inherited) {
+    if (!isRecord(schema)) {
+        return schema;
+    }
+    const node = { ...schema };
+    const examples = [...examplesOf(node), ...inherited];
+    // `enum` and `const` are already closed unions, and widening them with
+    // `(base & {})` would say the opposite of what the description says.
+    const closed = 'enum' in node || 'const' in node;
+    if (isRecord(node['properties'])) {
+        const properties = {};
+        for (const [name, property] of Object.entries(node['properties'])) {
+            properties[name] = annotate(property, 
+            // An object example is not a type: it is a set of property examples,
+            // one level down.
+            examples
+                .filter(isRecord)
+                .filter((example) => name in example)
+                .map((example) => example[name]));
+        }
+        node['properties'] = properties;
+    }
+    if (node['items'] !== undefined) {
+        node['items'] = annotate(node['items'], 
+        // Likewise an array example: element examples, one level down.
+        examples.filter(Array.isArray).flat());
+    }
+    // A composition describes the *same* value as the node holding it, so the
+    // node's examples belong to each branch.
+    for (const keyword of COMPOSITION_KEYWORDS) {
+        const branches = node[keyword];
+        if (Array.isArray(branches)) {
+            node[keyword] = branches.map((branch) => annotate(branch, examples));
+        }
+    }
+    // A named component is a *separate* schema that anything may point at, so it
+    // is annotated on its own and never with the referring site's examples: an
+    // example beside a `$ref` describes the property that refers, not the
+    // component every other property shares.
+    //
+    // Reached at all only because a component's examples are otherwise dropped
+    // entirely — nothing descends through a `$ref`, and named components are how
+    // essentially every real description is written.
+    for (const keyword of DEFINITION_KEYWORDS) {
+        const definitions = node[keyword];
+        if (isRecord(definitions)) {
+            node[keyword] = Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+                name,
+                annotate(definition, []),
+            ]));
+        }
+    }
+    if (!closed) {
+        const literals = openLiteralUnion(node, examples);
+        if (literals) {
+            node['tsType'] = literals;
+        }
+    }
+    return node;
+}
+/**
+ * `'A' | 'B' | (base & {})` for a primitive node with examples, or `undefined`
+ * when there is nothing to reflect.
+ *
+ * The `& {}` is what keeps the union open: without it TypeScript widens the
+ * whole thing back to `string` and the literals stop autocompleting.
+ */
+function openLiteralUnion(node, examples) {
+    const base = primitiveBase(node);
+    if (!base) {
+        return undefined;
+    }
+    // Sorted, not merely de-duplicated by insertion order: the union is
+    // reflected from the `examples` array, and an author reordering that array
+    // is not a change to what the API returns, so it must not be a change to
+    // the committed surface either.
+    const literals = [
+        ...new Set(examples
+            .filter((example) => typeof example === base)
+            .map((example) => JSON.stringify(example))),
+    ].sort();
+    if (literals.length === 0) {
+        return undefined;
+    }
+    return `${literals.join(' | ')} | (${base} & {})`;
+}
+/** The TypeScript primitive a node describes, if it describes exactly one. */
+function primitiveBase(node) {
+    const type = node['type'];
+    if (type === 'string') {
+        return 'string';
+    }
+    if (type === 'number' || type === 'integer') {
+        return 'number';
+    }
+    return undefined;
+}
+//# sourceMappingURL=example-reflection.js.map

package/dist/generation/types/example-reflection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-reflection.js","sourceRoot":"","sources":["../../../src/generation/types/example-reflection.ts"],"names":[],"mappings":"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"}

package/dist/generation/types/generate-type-surface.d.ts

@@ -0,0 +1,23 @@
+import type { TransactionCatalog } from '../../selectors/transaction-catalog.js';
+/** The two files the committed surface consists of. */
+export type TypeSurface = {
+    /** `Endpoints`, the spec-derived unions, and the schema declarations. */
+    requestTypes: string;
+    /** The `@thymian/hooks` authoring surface, typed against `Endpoints`. */
+    hooksApi: string;
+};
+export declare const REQUEST_TYPES_FILE = "request-types.d.ts";
+export declare const HOOKS_API_FILE = "hooks-api.d.ts";
+/**
+ * Emit the committed type surface for a loaded description.
+ *
+ * Deterministic by construction: unions are sorted, parameters are emitted in
+ * name order, declaration names come from the selector and the schema's role
+ * within the transaction (see `type-names.ts`), and `Endpoints` follows catalog
+ * order — which is sorted by selector. So reordering the source document, or
+ * renaming its title, changes nothing here; and because no name is positional,
+ * inserting an endpoint touches only the lines that endpoint owns plus the
+ * unions its method, status, path and media types widen.
+ */
+export declare function generateTypeSurface(catalog: TransactionCatalog): Promise<TypeSurface>;
+//# sourceMappingURL=generate-type-surface.d.ts.map

package/dist/generation/types/generate-type-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-type-surface.d.ts","sourceRoot":"","sources":["../../../src/generation/types/generate-type-surface.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAMjF,uDAAuD;AACvD,MAAM,MAAM,WAAW,GAAG;IACxB,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AACvD,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAoI/C;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,WAAW,CAAC,CAqNtB"}