@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/scope.js

@@ -0,0 +1,481 @@
+import { ParseError, flatMorph, hasDomain, isArray, isThunk, printable, throwInternalError, throwParseError } from "@ark/util";
+import { mergeConfigs } from "./config.js";
+import { GenericRoot, LazyGenericBody } from "./generic.js";
+import { nodeImplementationsByKind } from "./kinds.js";
+import { RootModule, bindModule } from "./module.js";
+import { nodesByRegisteredId, parseNode, registerNodeId, schemaKindOf, withId } from "./parse.js";
+import { Alias } from "./roots/alias.js";
+import { CompiledFunction, NodeCompiler } from "./shared/compile.js";
+import { $ark } from "./shared/registry.js";
+import { Traversal } from "./shared/traversal.js";
+import { arkKind, hasArkKind, isNode } from "./shared/utils.js";
+const schemaBranchesOf = (schema) => isArray(schema) ? schema
+    : "branches" in schema && isArray(schema.branches) ? schema.branches
+        : undefined;
+const throwMismatchedNodeRootError = (expected, actual) => throwParseError(`Node of kind ${actual} is not valid as a ${expected} definition`);
+export const writeDuplicateAliasError = (alias) => `#${alias} duplicates public alias ${alias}`;
+const scopesByName = {};
+$ark.ambient ??= {};
+let rawUnknownUnion;
+const rootScopeFnName = "function $";
+const precompile = (references) => bindPrecompilation(references, precompileReferences(references));
+const bindPrecompilation = (references, precompiler) => {
+    const precompilation = precompiler.write(rootScopeFnName, 4);
+    const compiledTraversals = precompiler.compile()();
+    for (const node of references) {
+        if (node.precompilation) {
+            // if node has already been bound to another scope or anonymous type, don't rebind it
+            continue;
+        }
+        node.traverseAllows =
+            compiledTraversals[`${node.id}Allows`].bind(compiledTraversals);
+        if (node.isRoot() && !node.allowsRequiresContext) {
+            // if the reference doesn't require context, we can assign over
+            // it directly to avoid having to initialize it
+            node.allows = node.traverseAllows;
+        }
+        node.traverseApply =
+            compiledTraversals[`${node.id}Apply`].bind(compiledTraversals);
+        if (compiledTraversals[`${node.id}Optimistic`]) {
+            ;
+            node.traverseOptimistic =
+                compiledTraversals[`${node.id}Optimistic`].bind(compiledTraversals);
+        }
+        node.precompilation = precompilation;
+    }
+};
+const precompileReferences = (references) => new CompiledFunction().return(references.reduce((js, node) => {
+    const allowsCompiler = new NodeCompiler({ kind: "Allows" }).indent();
+    node.compile(allowsCompiler);
+    const allowsJs = allowsCompiler.write(`${node.id}Allows`);
+    const applyCompiler = new NodeCompiler({ kind: "Apply" }).indent();
+    node.compile(applyCompiler);
+    const applyJs = applyCompiler.write(`${node.id}Apply`);
+    const result = `${js}${allowsJs},\n${applyJs},\n`;
+    if (!node.hasKind("union"))
+        return result;
+    const optimisticCompiler = new NodeCompiler({
+        kind: "Allows",
+        optimistic: true
+    }).indent();
+    node.compile(optimisticCompiler);
+    const optimisticJs = optimisticCompiler.write(`${node.id}Optimistic`);
+    return `${result}${optimisticJs},\n`;
+}, "{\n") + "}");
+export class BaseScope {
+    config;
+    resolvedConfig;
+    name;
+    get [arkKind]() {
+        return "scope";
+    }
+    referencesById = {};
+    references = [];
+    resolutions = {};
+    exportedNames = [];
+    aliases = {};
+    resolved = false;
+    nodesByHash = {};
+    intrinsic;
+    constructor(
+    /** The set of names defined at the root-level of the scope mapped to their
+     * corresponding definitions.**/
+    def, config) {
+        this.config = mergeConfigs($ark.config, config);
+        this.resolvedConfig = mergeConfigs($ark.resolvedConfig, config);
+        this.name =
+            this.resolvedConfig.name ??
+                `anonymousScope${Object.keys(scopesByName).length}`;
+        if (this.name in scopesByName)
+            throwParseError(`A Scope already named ${this.name} already exists`);
+        scopesByName[this.name] = this;
+        const aliasEntries = Object.entries(def).map(entry => this.preparseOwnAliasEntry(...entry));
+        for (const [k, v] of aliasEntries) {
+            let name = k;
+            if (k[0] === "#") {
+                name = k.slice(1);
+                if (name in this.aliases)
+                    throwParseError(writeDuplicateAliasError(name));
+                this.aliases[name] = v;
+            }
+            else {
+                if (name in this.aliases)
+                    throwParseError(writeDuplicateAliasError(k));
+                this.aliases[name] = v;
+                this.exportedNames.push(name);
+            }
+            if (!hasArkKind(v, "module") &&
+                !hasArkKind(v, "generic") &&
+                !isThunk(v)) {
+                const preparsed = this.preparseOwnDefinitionFormat(v, { alias: name });
+                this.resolutions[name] =
+                    hasArkKind(preparsed, "root") ?
+                        this.bindReference(preparsed)
+                        : this.createParseContext(preparsed).id;
+            }
+        }
+        // reduce union of all possible values reduces to unknown
+        rawUnknownUnion ??= this.node("union", {
+            branches: [
+                "string",
+                "number",
+                "object",
+                "bigint",
+                "symbol",
+                { unit: true },
+                { unit: false },
+                { unit: undefined },
+                { unit: null }
+            ]
+        }, { prereduced: true });
+        this.nodesByHash[rawUnknownUnion.hash] = this.node("intersection", {}, { prereduced: true });
+        this.intrinsic =
+            $ark.intrinsic ?
+                flatMorph($ark.intrinsic, (k, v) => 
+                // don't include cyclic aliases from JSON scope
+                k.startsWith("json") ? [] : [k, this.bindReference(v)])
+                // intrinsic won't be available during bootstrapping,  so we lie
+                // about the type here as an extrnal convenience
+                : {};
+    }
+    cacheGetter(name, value) {
+        Object.defineProperty(this, name, { value });
+        return value;
+    }
+    get internal() {
+        return this;
+    }
+    // json is populated when the scope is exported, so ensure it is populated
+    // before allowing external access
+    _json;
+    get json() {
+        if (!this._json)
+            this.export();
+        return this._json;
+    }
+    defineSchema(def) {
+        return def;
+    }
+    generic = (...params) => {
+        const $ = this;
+        return (def, possibleHkt) => new GenericRoot(params, possibleHkt ? new LazyGenericBody(def) : def, $, $, possibleHkt ?? null);
+    };
+    units = (values, opts) => {
+        const uniqueValues = [];
+        for (const value of values)
+            if (!uniqueValues.includes(value))
+                uniqueValues.push(value);
+        const branches = uniqueValues.map(unit => this.node("unit", { unit }, opts));
+        return this.node("union", branches, {
+            ...opts,
+            prereduced: true
+        });
+    };
+    lazyResolutions = [];
+    lazilyResolve(resolve, syntheticAlias) {
+        const node = this.node("alias", {
+            reference: syntheticAlias ?? "synthetic",
+            resolve
+        }, { prereduced: true });
+        if (!this.resolved)
+            this.lazyResolutions.push(node);
+        return node;
+    }
+    schema = (schema, opts) => this.finalize(this.parseSchema(schema, opts));
+    parseSchema = (schema, opts) => this.node(schemaKindOf(schema), schema, opts);
+    preparseNode(kinds, schema, opts) {
+        let kind = typeof kinds === "string" ? kinds : schemaKindOf(schema, kinds);
+        if (isNode(schema) && schema.kind === kind)
+            return schema;
+        if (kind === "alias" && !opts?.prereduced) {
+            const { reference } = Alias.implementation.normalize(schema, this);
+            if (reference.startsWith("$")) {
+                const resolution = this.resolveRoot(reference.slice(1));
+                schema = resolution;
+                kind = resolution.kind;
+            }
+        }
+        else if (kind === "union" && hasDomain(schema, "object")) {
+            const branches = schemaBranchesOf(schema);
+            if (branches?.length === 1) {
+                schema = branches[0];
+                kind = schemaKindOf(schema);
+            }
+        }
+        if (isNode(schema) && schema.kind === kind)
+            return schema;
+        const impl = nodeImplementationsByKind[kind];
+        const normalizedSchema = impl.normalize?.(schema, this) ?? schema;
+        // check again after normalization in case a node is a valid collapsed
+        // schema for the kind (e.g. sequence can collapse to element accepting a Node')
+        if (isNode(normalizedSchema)) {
+            return normalizedSchema.kind === kind ?
+                normalizedSchema
+                : throwMismatchedNodeRootError(kind, normalizedSchema.kind);
+        }
+        return {
+            ...opts,
+            $: this,
+            kind,
+            def: normalizedSchema,
+            prefix: opts.alias ?? kind
+        };
+    }
+    bindReference(reference) {
+        let bound;
+        if (isNode(reference)) {
+            bound =
+                reference.$ === this ?
+                    reference
+                    : new reference.constructor(reference.attachments, this);
+        }
+        else {
+            bound =
+                reference.$ === this ?
+                    reference
+                    : new GenericRoot(reference.params, reference.bodyDef, reference.$, this, reference.hkt);
+        }
+        if (!this.resolved) {
+            // we're still parsing the scope itself, so defer compilation but
+            // add the node as a reference
+            Object.assign(this.referencesById, bound.referencesById);
+        }
+        return bound;
+    }
+    resolveRoot(name) {
+        return (this.maybeResolveRoot(name) ??
+            throwParseError(writeUnresolvableMessage(name)));
+    }
+    maybeResolveRoot(name) {
+        const result = this.maybeResolve(name);
+        if (hasArkKind(result, "generic"))
+            return;
+        return result;
+    }
+    /** If name is a valid reference to a submodule alias, return its resolution  */
+    maybeResolveSubalias(name) {
+        return (maybeResolveSubalias(this.aliases, name) ??
+            maybeResolveSubalias(this.ambient, name));
+    }
+    get ambient() {
+        return $ark.ambient;
+    }
+    maybeResolve(name) {
+        const cached = this.resolutions[name];
+        if (cached) {
+            if (typeof cached !== "string")
+                return this.bindReference(cached);
+            const v = nodesByRegisteredId[cached];
+            if (hasArkKind(v, "root"))
+                return (this.resolutions[name] = v);
+            if (hasArkKind(v, "context")) {
+                if (v.phase === "resolving") {
+                    return this.node("alias", { reference: `$${name}` }, { prereduced: true });
+                }
+                if (v.phase === "resolved") {
+                    return throwInternalError(`Unexpected resolved context for was uncached by its scope: ${printable(v)}`);
+                }
+                v.phase = "resolving";
+                const node = this.bindReference(this.parseOwnDefinitionFormat(v.def, v));
+                v.phase = "resolved";
+                nodesByRegisteredId[node.id] = node;
+                nodesByRegisteredId[v.id] = node;
+                return (this.resolutions[name] = node);
+            }
+            return throwInternalError(`Unexpected nodesById entry for ${cached}: ${printable(v)}`);
+        }
+        let def = this.aliases[name] ?? this.ambient?.[name];
+        if (!def)
+            return this.maybeResolveSubalias(name);
+        def = this.normalizeRootScopeValue(def);
+        if (hasArkKind(def, "generic"))
+            return (this.resolutions[name] = this.bindReference(def));
+        if (hasArkKind(def, "module")) {
+            if (!def.root)
+                throwParseError(writeMissingSubmoduleAccessMessage(name));
+            return (this.resolutions[name] = this.bindReference(def.root));
+        }
+        return (this.resolutions[name] = this.parse(def, {
+            alias: name
+        }));
+    }
+    createParseContext(input) {
+        const id = input.id ?? registerNodeId(input.prefix);
+        return (nodesByRegisteredId[id] = Object.assign(input, {
+            [arkKind]: "context",
+            $: this,
+            id,
+            phase: "unresolved"
+        }));
+    }
+    traversal(root) {
+        return new Traversal(root, this.resolvedConfig);
+    }
+    import(...names) {
+        return new RootModule(flatMorph(this.export(...names), (alias, value) => [
+            `#${alias}`,
+            value
+        ]));
+    }
+    precompilation;
+    _exportedResolutions;
+    _exports;
+    export(...names) {
+        if (!this._exports) {
+            this._exports = {};
+            for (const name of this.exportedNames) {
+                const def = this.aliases[name];
+                this._exports[name] =
+                    hasArkKind(def, "module") ?
+                        bindModule(def, this)
+                        : bootstrapAliasReferences(this.maybeResolve(name));
+            }
+            // force node.resolution getter evaluation
+            // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+            for (const node of this.lazyResolutions)
+                node.resolution;
+            this._exportedResolutions = resolutionsOfModule(this, this._exports);
+            this._json = resolutionsToJson(this._exportedResolutions);
+            Object.assign(this.resolutions, this._exportedResolutions);
+            this.references = Object.values(this.referencesById);
+            if (!this.resolvedConfig.jitless) {
+                const precompiler = precompileReferences(this.references);
+                this.precompilation = precompiler.write(rootScopeFnName, 4);
+                bindPrecompilation(this.references, precompiler);
+            }
+            this.resolved = true;
+        }
+        const namesToExport = names.length ? names : this.exportedNames;
+        return new RootModule(flatMorph(namesToExport, (_, name) => [
+            name,
+            this._exports[name]
+        ]));
+    }
+    resolve(name) {
+        return this.export()[name];
+    }
+    node = (kinds, nodeSchema, opts = {}) => {
+        const ctxOrNode = this.preparseNode(kinds, nodeSchema, opts);
+        if (isNode(ctxOrNode))
+            return this.bindReference(ctxOrNode);
+        const ctx = this.createParseContext(ctxOrNode);
+        const node = parseNode(ctx);
+        const bound = this.bindReference(node);
+        return (nodesByRegisteredId[ctx.id] = bound);
+    };
+    parse = (def, opts = {}) => this.finalize(this.parseDefinition(def, opts));
+    parseDefinition(def, opts = {}) {
+        if (hasArkKind(def, "root"))
+            return this.bindReference(def);
+        const ctxInputOrNode = this.preparseOwnDefinitionFormat(def, opts);
+        if (hasArkKind(ctxInputOrNode, "root"))
+            return this.bindReference(ctxInputOrNode);
+        const ctx = this.createParseContext(ctxInputOrNode);
+        nodesByRegisteredId[ctx.id] = ctx;
+        let node = this.bindReference(this.parseOwnDefinitionFormat(def, ctx));
+        // if the node is recursive e.g. { box: "this" }, we need to make sure it
+        // has the original id from context so that its references compile correctly
+        if (node.isCyclic)
+            node = withId(node, ctx.id);
+        nodesByRegisteredId[ctx.id] = node;
+        return node;
+    }
+    finalize(node) {
+        bootstrapAliasReferences(node);
+        if (!node.precompilation && !this.resolvedConfig.jitless)
+            precompile(node.references);
+        return node;
+    }
+}
+export class SchemaScope extends BaseScope {
+    parseOwnDefinitionFormat(def, ctx) {
+        return parseNode(ctx);
+    }
+    preparseOwnDefinitionFormat(schema, opts) {
+        return this.preparseNode(schemaKindOf(schema), schema, opts);
+    }
+    preparseOwnAliasEntry(k, v) {
+        return [k, v];
+    }
+    normalizeRootScopeValue(v) {
+        return v;
+    }
+}
+const bootstrapAliasReferences = (resolution) => {
+    const aliases = resolution.references.filter(node => node.hasKind("alias"));
+    for (const aliasNode of aliases) {
+        Object.assign(aliasNode.referencesById, aliasNode.resolution.referencesById);
+        for (const ref of resolution.references) {
+            if (aliasNode.id in ref.referencesById)
+                Object.assign(ref.referencesById, aliasNode.referencesById);
+        }
+    }
+    return resolution;
+};
+const resolutionsToJson = (resolutions) => flatMorph(resolutions, (k, v) => [
+    k,
+    hasArkKind(v, "root") || hasArkKind(v, "generic") ? v.json
+        : hasArkKind(v, "module") ? resolutionsToJson(v)
+            : throwInternalError(`Unexpected resolution ${printable(v)}`)
+]);
+const maybeResolveSubalias = (base, name) => {
+    const dotIndex = name.indexOf(".");
+    if (dotIndex === -1)
+        return;
+    const dotPrefix = name.slice(0, dotIndex);
+    const prefixSchema = base[dotPrefix];
+    // if the name includes ".", but the prefix is not an alias, it
+    // might be something like a decimal literal, so just fall through to return
+    if (prefixSchema === undefined)
+        return;
+    if (!hasArkKind(prefixSchema, "module"))
+        return throwParseError(writeNonSubmoduleDotMessage(dotPrefix));
+    const subalias = name.slice(dotIndex + 1);
+    const resolution = prefixSchema[subalias];
+    if (resolution === undefined)
+        return maybeResolveSubalias(prefixSchema, subalias);
+    if (hasArkKind(resolution, "root") || hasArkKind(resolution, "generic"))
+        return resolution;
+    if (hasArkKind(resolution, "module")) {
+        return (resolution.root ??
+            throwParseError(writeMissingSubmoduleAccessMessage(name)));
+    }
+    throwInternalError(`Unexpected resolution for alias '${name}': ${printable(resolution)}`);
+};
+export const schemaScope = (aliases, config) => new SchemaScope(aliases, config);
+export const rootSchemaScope = new SchemaScope({});
+export const parseAsSchema = (def, opts) => {
+    try {
+        return rootSchema(def, opts);
+    }
+    catch (e) {
+        if (e instanceof ParseError)
+            return e;
+        throw e;
+    }
+};
+const resolutionsOfModule = ($, typeSet) => {
+    const result = {};
+    for (const k in typeSet) {
+        const v = typeSet[k];
+        if (hasArkKind(v, "module")) {
+            const innerResolutions = resolutionsOfModule($, v);
+            const prefixedResolutions = flatMorph(innerResolutions, (innerK, innerV) => [`${k}.${innerK}`, innerV]);
+            Object.assign(result, prefixedResolutions);
+        }
+        else if (hasArkKind(v, "root") || hasArkKind(v, "generic"))
+            result[k] = v;
+        else
+            throwInternalError(`Unexpected scope resolution ${printable(v)}`);
+    }
+    return result;
+};
+export const writeUnresolvableMessage = (token) => `'${token}' is unresolvable`;
+export const writeNonSubmoduleDotMessage = (name) => `'${name}' must reference a module to be accessed using dot syntax`;
+export const writeMissingSubmoduleAccessMessage = (name) => `Reference to submodule '${name}' must specify an alias`;
+// ensure the scope is resolved so JIT will be applied to future types
+rootSchemaScope.export();
+export const rootSchema = rootSchemaScope.schema;
+export const node = rootSchemaScope.node;
+export const defineSchema = rootSchemaScope.defineSchema;
+export const genericNode = rootSchemaScope.generic;

package/node_modules/@ark/schema/out/shared/compile.d.ts

@@ -0,0 +1,62 @@
+import { CastableBase, type Fn } from "@ark/util";
+import type { BaseNode } from "../node.ts";
+import type { NodeId } from "../parse.ts";
+import type { TraversalKind } from "./traversal.ts";
+export type CoercibleValue = string | number | boolean | null | undefined;
+export declare class CompiledFunction<compiledSignature = (...args: unknown[]) => unknown, args extends readonly string[] = readonly string[]> extends CastableBase<{
+    [k in args[number]]: k;
+}> {
+    readonly argNames: args;
+    readonly body = "";
+    constructor(...args: args);
+    indentation: number;
+    indent(): this;
+    dedent(): this;
+    prop(key: PropertyKey, optional?: boolean): string;
+    index(key: string | number, optional?: boolean): string;
+    line(statement: string): this;
+    const(identifier: string, expression: CoercibleValue): this;
+    let(identifier: string, expression: CoercibleValue): this;
+    set(identifier: string, expression: CoercibleValue): this;
+    if(condition: string, then: (self: this) => this): this;
+    elseIf(condition: string, then: (self: this) => this): this;
+    else(then: (self: this) => this): this;
+    /** Current index is "i" */
+    for(until: string, body: (self: this) => this, initialValue?: CoercibleValue): this;
+    /** Current key is "k" */
+    forIn(object: string, body: (self: this) => this): this;
+    block(prefix: string, contents: (self: this) => this, suffix?: string): this;
+    return(expression?: CoercibleValue): this;
+    write(name?: string, indent?: number): string;
+    compile(): compiledSignature;
+}
+export declare const compileSerializedValue: (value: unknown) => string;
+export declare const compileLiteralPropAccess: (key: PropertyKey, optional?: boolean) => string;
+export declare const serializeLiteralKey: (key: PropertyKey) => string;
+export declare const indexPropAccess: (key: string, optional?: boolean) => string;
+export interface InvokeOptions extends ReferenceOptions {
+    arg?: string;
+}
+export interface ReferenceOptions {
+    kind?: TraversalKind;
+    bind?: string;
+}
+export declare namespace NodeCompiler {
+    interface Context {
+        kind: TraversalKind;
+        optimistic?: true;
+    }
+}
+export declare class NodeCompiler extends CompiledFunction<Fn, ["data", "ctx"]> {
+    traversalKind: TraversalKind;
+    optimistic: boolean;
+    constructor(ctx: NodeCompiler.Context);
+    invoke(node: BaseNode | NodeId, opts?: InvokeOptions): string;
+    referenceToId(id: NodeId, opts?: ReferenceOptions): string;
+    requiresContextFor(node: BaseNode): boolean;
+    initializeErrorCount(): this;
+    returnIfFail(): this;
+    returnIfFailFast(): this;
+    traverseKey(keyExpression: string, accessExpression: string, node: BaseNode): this;
+    check(node: BaseNode, opts?: InvokeOptions): this;
+}

package/node_modules/@ark/schema/out/shared/compile.js

@@ -0,0 +1,145 @@
+import { CastableBase, DynamicFunction, hasDomain, isDotAccessible, serializePrimitive } from "@ark/util";
+import { registeredReference } from "./registry.js";
+export class CompiledFunction extends CastableBase {
+    argNames;
+    body = "";
+    constructor(...args) {
+        super();
+        this.argNames = args;
+        for (const arg of args) {
+            if (arg in this) {
+                throw new Error(`Arg name '${arg}' would overwrite an existing property on FunctionBody`);
+            }
+            ;
+            this[arg] = arg;
+        }
+    }
+    indentation = 0;
+    indent() {
+        this.indentation += 4;
+        return this;
+    }
+    dedent() {
+        this.indentation -= 4;
+        return this;
+    }
+    prop(key, optional = false) {
+        return compileLiteralPropAccess(key, optional);
+    }
+    index(key, optional = false) {
+        return indexPropAccess(`${key}`, optional);
+    }
+    line(statement) {
+        ;
+        this.body += `${" ".repeat(this.indentation)}${statement}\n`;
+        return this;
+    }
+    const(identifier, expression) {
+        this.line(`const ${identifier} = ${expression}`);
+        return this;
+    }
+    let(identifier, expression) {
+        return this.line(`let ${identifier} = ${expression}`);
+    }
+    set(identifier, expression) {
+        return this.line(`${identifier} = ${expression}`);
+    }
+    if(condition, then) {
+        return this.block(`if (${condition})`, then);
+    }
+    elseIf(condition, then) {
+        return this.block(`else if (${condition})`, then);
+    }
+    else(then) {
+        return this.block("else", then);
+    }
+    /** Current index is "i" */
+    for(until, body, initialValue = 0) {
+        return this.block(`for (let i = ${initialValue}; ${until}; i++)`, body);
+    }
+    /** Current key is "k" */
+    forIn(object, body) {
+        return this.block(`for (const k in ${object})`, body);
+    }
+    block(prefix, contents, suffix = "") {
+        this.line(`${prefix} {`);
+        this.indent();
+        contents(this);
+        this.dedent();
+        return this.line(`}${suffix}`);
+    }
+    return(expression = "") {
+        return this.line(`return ${expression}`);
+    }
+    write(name = "anonymous", indent = 0) {
+        return `${name}(${this.argNames.join(", ")}) { ${indent ?
+            this.body
+                .split("\n")
+                .map(l => " ".repeat(indent) + `${l}`)
+                .join("\n")
+            : this.body} }`;
+    }
+    compile() {
+        return new DynamicFunction(...this.argNames, this.body);
+    }
+}
+export const compileSerializedValue = (value) => hasDomain(value, "object") || typeof value === "symbol" ?
+    registeredReference(value)
+    : serializePrimitive(value);
+export const compileLiteralPropAccess = (key, optional = false) => {
+    if (typeof key === "string" && isDotAccessible(key))
+        return `${optional ? "?" : ""}.${key}`;
+    return indexPropAccess(serializeLiteralKey(key), optional);
+};
+export const serializeLiteralKey = (key) => typeof key === "symbol" ? registeredReference(key) : JSON.stringify(key);
+export const indexPropAccess = (key, optional = false) => `${optional ? "?." : ""}[${key}]`;
+export class NodeCompiler extends CompiledFunction {
+    traversalKind;
+    optimistic;
+    constructor(ctx) {
+        super("data", "ctx");
+        this.traversalKind = ctx.kind;
+        this.optimistic = ctx.optimistic === true;
+    }
+    invoke(node, opts) {
+        const arg = opts?.arg ?? this.data;
+        const requiresContext = typeof node === "string" ? true : this.requiresContextFor(node);
+        const id = typeof node === "string" ? node : node.id;
+        if (requiresContext)
+            return `${this.referenceToId(id, opts)}(${arg}, ${this.ctx})`;
+        return `${this.referenceToId(id, opts)}(${arg})`;
+    }
+    referenceToId(id, opts) {
+        const invokedKind = opts?.kind ?? this.traversalKind;
+        const base = `this.${id}${invokedKind}`;
+        return opts?.bind ? `${base}.bind(${opts?.bind})` : base;
+    }
+    requiresContextFor(node) {
+        return this.traversalKind === "Apply" || node.allowsRequiresContext;
+    }
+    initializeErrorCount() {
+        return this.const("errorCount", "ctx.currentErrorCount");
+    }
+    returnIfFail() {
+        return this.if("ctx.currentErrorCount > errorCount", () => this.return());
+    }
+    returnIfFailFast() {
+        return this.if("ctx.failFast && ctx.currentErrorCount > errorCount", () => this.return());
+    }
+    traverseKey(keyExpression, accessExpression, node) {
+        const requiresContext = this.requiresContextFor(node);
+        if (requiresContext)
+            this.line(`${this.ctx}.path.push(${keyExpression})`);
+        this.check(node, {
+            arg: accessExpression
+        });
+        if (requiresContext)
+            this.line(`${this.ctx}.path.pop()`);
+        return this;
+    }
+    check(node, opts) {
+        return this.traversalKind === "Allows" ?
+            this.if(`!${this.invoke(node, opts)}`, () => this.return(false))
+            : this.line(this.invoke(node, opts));
+    }
+}