behavior-contracts 0.2.4 → 0.2.6

package/dist/generator/emit-raw-abi-go.d.ts

@@ -0,0 +1,45 @@
+/**
+ * emit-raw-abi-go.ts — Go RAW handler ABI emitter (bc#76): the de-boxed typed path.
+ *
+ * # What this replaces
+ *
+ * The boxed typed emitter (emit-straightline-typed-go.ts) generates
+ * `marshal_T*(raw Value) (T*, error)`: the handler builds a full dynamic `*Obj` Value tree
+ * and the marshaller WALKS it into a struct — a Value->struct conversion LAYERED on top of
+ * boxing. The residual ~22% Rust gap #75 measured is that Value/*Obj clone at the ABI.
+ *
+ * # What this emits
+ *
+ * A RAW module that materializes structs DIRECTLY from a `RawValue` (native-backed, NOT a
+ * Value/*Obj — see go/rawabi.go). The generated code:
+ *
+ *   - `marshal_raw_T*(raw dslcontracts.RawValue) (T*, error)`: reads each field via
+ *     `RawRow.Field` / native scalar type-switch / `[]RawValue` iteration — straight into
+ *     the concrete struct. It NEVER constructs a `*Obj`/`Value` on the row data plane.
+ *   - `run_typed_raw_<comp>(handlers RawComponentExec, input *Obj) (Value, error)`: drives
+ *     the plan with the RunPlan primitive (plan SSoT, reused), evaluates ports with the
+ *     native/primitive straight-line dialect (unchanged — ports are Value-space, off the
+ *     row data plane), calls the RAW handler (`ExecRawHandler` -> `RawValue`), and
+ *     materializes the node struct via `marshal_raw_T*` at the boundary. The output is
+ *     assembled as a struct and serialized to a Value ONLY at the final return boundary
+ *     (the equivalence pin), exactly as the boxed typed path does — so the OBSERVED result
+ *     equals run_behavior while the data plane never boxed.
+ *   - `BindRaw(handlers RawComponentExec) map[string]func(*Obj)(Value,error)`: the raw
+ *     dispatch surface (mirrors Bind).
+ *
+ * # Scope
+ *
+ * The raw de-box covers the componentRef read-handler shape — exactly graphddb's row
+ * hydrator (AttributeValue -> struct) where the measured gap lives. Typed map/cond nodes
+ * are out of raw scope for now: the emitter LOUD-fails (UNSUPPORTED_NODE_STRAIGHTLINE) so a
+ * consumer regenerates those components on the boxed typed path rather than getting a module
+ * that silently re-boxes. TS/py/php are unaffected (runtime de-box targets are go/rust).
+ */
+import type { EmitterPlugin } from "./core.js";
+/**
+ * goRawAbiEmitter — language id `go-typed-raw` (bc#76). Emits the straight-line body (for
+ * untyped components / helpers) plus the RAW-ABI de-boxed layer (struct materialized directly
+ * from RawValue) and the BindRaw surface. Requires at least one outType/outputType annotation.
+ */
+export declare const goRawAbiEmitter: EmitterPlugin;
+//# sourceMappingURL=emit-raw-abi-go.d.ts.map

package/dist/generator/emit-raw-abi-go.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-raw-abi-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-raw-abi-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AAuY5D;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,aAM7B,CAAC"}

package/dist/generator/emit-raw-abi-go.js

@@ -0,0 +1,345 @@
+import { GeneratorFailure } from "./core.js";
+import { buildTypePlan, deriveTypeRef, findDecl } from "./typed.js";
+import { goTypedInternals } from "./emit-straightline-typed-go.js";
+const { PKG, sanitize, goFieldName, renderTypeRef, goScalar, typedLocal, isTypedComponent, collectTypedNodes, hasAnyTypeAnnotation, emitTypeDecls, emitSerializers, emitMarshallers, serializeTyped, emitTypedValue, buildComponentPlanForTyped, emitOpsLiteral, emitBehaviorPlanLiteral, goPortVar, setGoForceRunPlanHelpers, goStraightlineEmitter, } = goTypedInternals;
+// ── RAW marshallers (the de-box): read a RawValue field-by-field into a concrete struct ──
+/** Emit `marshal_raw_T*` for every named struct in the plan. */
+function emitRawMarshallers(plan) {
+    if (plan.decls.length === 0)
+        return "";
+    return plan.decls.map((d) => emitOneRawMarshaller(d, plan)).join("\n\n");
+}
+function emitOneRawMarshaller(d, plan) {
+    const lines = [];
+    lines.push(`func marshal_raw_${d.name}(raw ${PKG}.RawValue) (${d.name}, error) {`);
+    lines.push(`\tvar out ${d.name}`);
+    // The row seam: a RawRow (native accessor), NOT a *Obj. This is the de-box — no dynamic
+    // Value tree is walked; RawRow.Field is a direct native read.
+    lines.push(`\trow, ok := raw.(${PKG}.RawRow)`);
+    lines.push(`\tif !ok {`);
+    lines.push(`\t\treturn out, ${PKG}.NewExprFailure("TYPE_MISMATCH", "typed raw marshal ${d.name}: expected obj, got "+${PKG}.RawFieldType(raw))`);
+    lines.push(`\t}`);
+    for (const f of d.fields) {
+        const goName = goFieldName(f.name);
+        const keyLit = JSON.stringify(f.name);
+        lines.push(`\t{`);
+        lines.push(`\t\tfv, present := row.Field(${keyLit})`);
+        lines.push(`\t\tif !present {`);
+        lines.push(`\t\t\treturn out, ${PKG}.NewExprFailure("MISSING_PROP", "typed raw marshal ${d.name}: missing property ."+${keyLit})`);
+        lines.push(`\t\t}`);
+        lines.push(emitRawFieldMaterialize(`out.${goName}`, "fv", f.type, plan, 2));
+        lines.push(`\t}`);
+    }
+    lines.push(`\treturn out, nil`);
+    lines.push(`}`);
+    return lines.join("\n");
+}
+/**
+ * emitRawFieldMaterialize — materialize `src` (a RawValue expr) into typed `target` per
+ * `ref`. scalar -> native type-switch on RawValue, named -> marshal_raw_T*, arr ->
+ * []RawValue loop, opt -> null branch. All concrete Go types; no *Obj/Value ever built.
+ */
+function emitRawFieldMaterialize(target, src, ref, plan, indent) {
+    const t = "\t".repeat(indent);
+    switch (ref.kind) {
+        case "scalar": {
+            if (ref.scalar === "null") {
+                // null-only field: store nil (the RawValue must be nil; mismatches are rare and the
+                // boxed path also passes through, so keep symmetric — a non-nil here is not asserted).
+                return `${t}${target} = nil`;
+            }
+            const gt = goScalar(ref.scalar);
+            const at = ref.scalar === "int" ? "int64" : ref.scalar === "float" ? "float64" : gt;
+            return [
+                `${t}sv, sok := ${src}.(${at})`,
+                `${t}if !sok {`,
+                `${t}\treturn out, ${PKG}.NewExprFailure("TYPE_MISMATCH", "typed raw marshal: expected ${ref.scalar}, got "+${PKG}.RawFieldType(${src}))`,
+                `${t}}`,
+                `${t}${target} = sv`,
+            ].join("\n");
+        }
+        case "named": {
+            return [
+                `${t}mv, merr := marshal_raw_${ref.name}(${src})`,
+                `${t}if merr != nil {`,
+                `${t}\treturn out, merr`,
+                `${t}}`,
+                `${t}${target} = mv`,
+            ].join("\n");
+        }
+        case "arr": {
+            const elemGo = renderTypeRef(ref.elem);
+            const inner = emitRawFieldMaterialize("elemOut", "elemRaw", ref.elem, plan, indent + 1);
+            return [
+                `${t}arr, aok := ${src}.([]${PKG}.RawValue)`,
+                `${t}if !aok {`,
+                `${t}\treturn out, ${PKG}.NewExprFailure("TYPE_MISMATCH", "typed raw marshal: expected arr, got "+${PKG}.RawFieldType(${src}))`,
+                `${t}}`,
+                `${t}slice := make([]${elemGo}, 0, len(arr))`,
+                `${t}for _, elemRaw := range arr {`,
+                `${t}\tvar elemOut ${elemGo}`,
+                inner,
+                `${t}\tslice = append(slice, elemOut)`,
+                `${t}}`,
+                `${t}${target} = slice`,
+            ].join("\n");
+        }
+        case "opt": {
+            const innerGo = renderTypeRef(ref.inner);
+            const inner = emitRawFieldMaterialize("optOut", src, ref.inner, plan, indent + 1);
+            return [
+                `${t}if ${src} == nil {`,
+                `${t}\t${target} = nil`,
+                `${t}} else {`,
+                `${t}\tvar optOut ${innerGo}`,
+                inner,
+                `${t}\t${target} = &optOut`,
+                `${t}}`,
+            ].join("\n");
+        }
+    }
+}
+/** Node materializer for scalar/arr/opt outType nodes on the raw path (fail-closed). */
+function rawNodeMaterializerName(compName, nodeId) {
+    return `materializeRawNode_${sanitize(compName)}_${nodeId.replace(/[^A-Za-z0-9_]/g, "_")}`;
+}
+function emitRawNodeMaterializers(comp, typedNodes, plan) {
+    const parts = [];
+    for (const [id, ref] of typedNodes.entries()) {
+        if (ref.kind === "named")
+            continue;
+        const ty = renderTypeRef(ref);
+        const fn = rawNodeMaterializerName(comp.name, id);
+        const body = emitRawFieldMaterialize("out", "raw", ref, plan, 1);
+        parts.push(`func ${fn}(raw ${PKG}.RawValue) (${ty}, error) {\n\tvar out ${ty}\n${body}\n\treturn out, nil\n}`);
+    }
+    return parts.join("\n\n");
+}
+// ── RAW runner: RunPlan-driven struct-native exec through the RAW handler ─────────────
+const PORT_SCOPE = "portScope()";
+function emitRawStoreNode(nodeId, srcExpr, ref, compName, indent, producedName) {
+    const t = "\t".repeat(indent);
+    if (ref === undefined)
+        return `${t}_ = ${srcExpr}`;
+    const prod = `\n${t}${producedName(nodeId)} = true`;
+    const store = `${t}scopeMu.Lock()\n${t}${typedLocal(nodeId)} = tv${prod}\n${t}scopeMu.Unlock()`;
+    const call = ref.kind === "named" ? `marshal_raw_${ref.name}(${srcExpr})` : `${rawNodeMaterializerName(compName, nodeId)}(${srcExpr})`;
+    return `${t}tv, merr := ${call}\n${t}if merr != nil {\n${t}\treturn abort(idx, merr)\n${t}}\n${store}`;
+}
+function assertRawSupported(comp) {
+    for (const n of comp.body) {
+        if ("map" in n || "cond" in n) {
+            const ot = n.outType;
+            if (ot !== undefined) {
+                throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go raw ABI (bc#76): component '${comp.name}' node '${n.id}' is a typed ${"map" in n ? "map" : "cond"} node. The raw handler ABI de-box currently covers the componentRef read-handler shape (graphddb's row hydrator). Regenerate this component on the boxed typed path (go-typed) — do NOT emit a raw module that re-boxes map/cond results.`);
+            }
+        }
+    }
+}
+function emitRawExecArm(op, compName, typedNodes, plan, producedName) {
+    if (op.kind !== "componentRef") {
+        // Guarded by assertRawSupported for typed nodes; an UNtyped map/cond in a typed
+        // component cannot reach here on the raw path (fail-closed at generation).
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", `go raw ABI (bc#76): node '${op.id}' kind '${op.kind}' is not supported on the raw path (componentRef only). Regenerate on go-typed.`);
+    }
+    const gp = goPortVar;
+    const portEvals = op.ports
+        .map((p) => `\t\t\t${gp(p.name)}, err := ${p.expr}
+\t\t\tif err != nil {
+\t\t\t\treturn abort(idx, err)
+\t\t\t}
+\t\t\tports.Set(${JSON.stringify(p.name)}, ${gp(p.name)})`)
+        .join("\n");
+    const body = op.ports.length === 0 ? "" : `\n${portEvals}`;
+    const ref = typedNodes.get(op.id);
+    const materialize = emitRawStoreNode(op.id, "outcome.Ok", ref, compName, 3, producedName);
+    return `\t\tif i == ${op.index} {
+\t\t\tports := ${PKG}.NewObj()${body}
+\t\t\toutcome, resolved := ${PKG}.ExecRawHandler(handlers, ${JSON.stringify(op.id)}, ${JSON.stringify(op.component)}, ports, nil)
+\t\t\tif !resolved {
+\t\t\t\treturn abort(idx, ${PKG}.NewBehaviorFailure("UNKNOWN_COMPONENT", "component '${op.component}' has no handler (fail-closed)"))
+\t\t\t}
+\t\t\tif outcome.IsError {
+\t\t\t\treturn ${PKG}.ErrOutcome(outcome.Err)
+\t\t\t}
+${materialize}
+\t\t\treturn ${PKG}.OkOutcome(nil)
+\t\t}`;
+}
+function emitRawRunner(comp, plan) {
+    assertRawSupported(comp);
+    const fn = sanitize(comp.name);
+    const cplan = buildComponentPlanForTyped(comp);
+    const typedNodes = collectTypedNodes(comp, plan);
+    const decls = [...typedNodes.entries()]
+        .map(([id, ref]) => `\tvar ${typedLocal(id)} ${renderTypeRef(ref)}`)
+        .join("\n");
+    const producedName = (id) => `__produced_${id.replace(/[^A-Za-z0-9_]/g, "_")}`;
+    const producedDecls = [...typedNodes.keys()]
+        .map((id) => `\t${producedName(id)} := false\n\t_ = ${producedName(id)}`)
+        .join("\n");
+    // #74: expose produced typed node results in the port scope by serializing the struct
+    // cells on demand (same discipline as the boxed typed runner — the struct is SoT).
+    const portScopeNodeInjections = [...typedNodes.entries()]
+        .map(([id, ref]) => {
+        const ser = serializeTyped(typedLocal(id), ref, plan);
+        return `\t\tif ${producedName(id)} {\n\t\t\ts.Set(${JSON.stringify(id)}, ${ser})\n\t\t}`;
+    })
+        .join("\n");
+    const arms = cplan.ops.map((op) => emitRawExecArm(op, comp.name, typedNodes, plan, producedName)).join("\n");
+    const planLiteral = comp.plan ? emitBehaviorPlanLiteral(comp.plan) : `(*${PKG}.ExecutionPlanSpec)(nil)`;
+    const outRef = comp.outputType !== undefined ? deriveTypeRef(comp.outputType, plan) : undefined;
+    const out = emitTypedValue(comp.output, outRef, typedNodes, plan);
+    const outRefFinal = out.ref ?? outRef;
+    const serialized = outRefFinal ? serializeTyped("__typed_out", outRefFinal, plan) : "__typed_out";
+    return `// run_typed_raw_${fn} — RAW-ABI STRUCT-NATIVE exec (bc#76 de-box): the RunPlan primitive drives the
+// plan (plan SSoT); per-node arms call the RAW handler (ExecRawHandler -> RawValue, NOT a boxed Value)
+// and materialize the node's outType struct DIRECTLY from the RawValue via marshal_raw_T*. The dynamic
+// Value/*Obj tree is NEVER built on the row data plane — that is the de-box the boxed typed path only
+// LAYERED. The output is assembled as a struct and serialized to a Value ONLY at the final return
+// boundary (the equivalence pin), so the OBSERVED result equals run_behavior. Called by BindRaw.
+func run_typed_raw_${fn}(handlers ${PKG}.RawComponentExec, input *${PKG}.Obj) (${PKG}.Value, error) {
+\tops := ${emitOpsLiteral(cplan)}
+\tif input == nil {
+\t\tinput = ${PKG}.NewObj()
+\t}
+${decls ? decls + "\n" : ""}${producedDecls ? producedDecls + "\n" : ""}\tvar scopeMu sync.Mutex
+\t_ = scopeMu.Unlock
+\tportScope := func() *${PKG}.Obj {
+\t\ts := ${PKG}.NewObj()
+\t\tfor _, k := range input.Keys {
+\t\t\ts.Set(k, input.Vals[k])
+\t\t}
+${portScopeNodeInjections ? "\t\tscopeMu.Lock()\n" + portScopeNodeInjections + "\n\t\tscopeMu.Unlock()\n" : ""}\t\treturn s
+\t}
+\t_ = portScope
+\texecErrs := make([]error, len(ops))
+\tabort := func(idx int, err error) ${PKG}.ExecOutcome {
+\t\texecErrs[idx] = err
+\t\treturn ${PKG}.ErrOutcome("aborted")
+\t}
+\texec := func(op ${PKG}.OpSpec, _ ${PKG}.Value) ${PKG}.ExecOutcome {
+\t\tidx := -1
+\t\tfor k := range ops {
+\t\t\tif ops[k].ID == op.ID {
+\t\t\t\tidx = k
+\t\t\t\tbreak
+\t\t\t}
+\t\t}
+\t\ti := idx
+${arms}
+\t\treturn abort(idx, ${PKG}.NewBehaviorFailure("UNKNOWN_NODE_KIND", "op '"+op.ID+"' has no generated raw exec arm (fail-closed)"))
+\t}
+\tplan := ${planLiteral}
+\trun, err := ${PKG}.RunPlan(plan, ops, exec)
+\tif firstErr := ${PKG}.FirstExecErrInVisitOrder(execErrs, plan, len(ops), err); firstErr != nil {
+\t\treturn nil, firstErr
+\t}
+\tif err != nil {
+\t\treturn nil, err
+\t}
+\t_ = run
+\t__typed_out := ${out.expr}
+\t_ = __typed_out
+\treturn ${serialized}, nil
+}`;
+}
+// ── BindRaw dispatch surface ──────────────────────────────────────────────────────────
+function emitBindRaw(ctx) {
+    const arms = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => {
+        const fn = sanitize(c.name);
+        return `\tm[${JSON.stringify(c.name)}] = func(input *${PKG}.Obj) (${PKG}.Value, error) {\n\t\treturn run_typed_raw_${fn}(handlers, input)\n\t}`;
+    })
+        .join("\n");
+    return `// BindRaw is the RAW-ABI dispatch surface (bc#76): it binds a RawComponentExec (native-backed
+// handler results) to the de-boxed struct-native runners. Only typed components are exposed on the raw
+// path; a consumer keeps untyped components on the boxed Bind. This mirrors Bind but drives the raw runner.
+func BindRaw(handlers ${PKG}.RawComponentExec) map[string]func(*${PKG}.Obj) (${PKG}.Value, error) {
+\tm := map[string]func(*${PKG}.Obj) (${PKG}.Value, error){}
+${arms}
+\treturn m
+}`;
+}
+// ── module assembly ──────────────────────────────────────────────────────────────────
+function emit(ctx) {
+    const typed = hasAnyTypeAnnotation(ctx);
+    if (!typed) {
+        throw new GeneratorFailure("UNSUPPORTED_NODE_STRAIGHTLINE", "go raw ABI (bc#76): the IR has no outType/outputType annotations — there is nothing to de-box. Use go-straightline for untyped IR.");
+    }
+    // Reuse the straight-line body so port evaluation helpers (slRef/slConcat/slPart) and the
+    // RunPlan primitive helpers are present (raw runner reuses them; ports are Value-space).
+    setGoForceRunPlanHelpers(true);
+    const straightlineCode = goStraightlineEmitter.emit(ctx);
+    setGoForceRunPlanHelpers(false);
+    const plan = buildTypePlan(ctx.ir);
+    const decls = emitTypeDecls(plan);
+    const rawMarshallers = emitRawMarshallers(plan);
+    const serializers = emitSerializers(plan);
+    // Boxed marshallers exist ONLY for the Value-space output-assembly fallback (mustMarshal_*),
+    // reached only when a component output directly references an INPUT PARAM of a named type — a
+    // Value-space boundary read, NOT the row data plane. The ROW data plane (handler result ->
+    // struct) is de-boxed via marshal_raw_* in the runner (asserted by the anti-sham gate).
+    const boxedMarshallers = emitMarshallers(plan);
+    const mustHelpers = goTypedInternals.emitMustHelpers(plan);
+    const arrOptNodeHelpers = goTypedInternals.emitArrOptNodeHelpers(ctx, plan);
+    const nodeMaterializers = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => {
+        const typedNodes = new Map();
+        for (const n of c.body) {
+            if ("map" in n)
+                continue;
+            const ot = n.outType;
+            if (ot !== undefined)
+                typedNodes.set(n.id, deriveTypeRef(ot, plan));
+        }
+        return emitRawNodeMaterializers(c, typedNodes, plan);
+    })
+        .filter((s) => s.length > 0)
+        .join("\n\n");
+    const runners = ctx.ir.components
+        .filter((c) => isTypedComponent(c))
+        .map((c) => emitRawRunner(c, plan))
+        .join("\n\n");
+    const bindRaw = emitBindRaw(ctx);
+    const banner = `// ── RAW handler ABI layer (bc#76 — Go de-box: struct materialized DIRECTLY from the wire payload) ──
+// This layer is ADDITIVE to the straight-line body above. A RawComponentExec handler returns a
+// RawValue (native-backed, NOT a *Obj/Value tree — see go/rawabi.go). marshal_raw_T* reads it via
+// RawRow.Field / native scalar type-switch straight into the concrete struct: the dynamic Value tree
+// the boxed typed path built and then re-walked NEVER exists here. BindRaw drives the de-boxed runners.`;
+    const sections = [
+        banner,
+        decls || undefined,
+        rawMarshallers
+            ? `// RAW marshallers (§4.4, de-box): materialize a concrete struct field-by-field from a native RawValue.\n// NO *Obj/NewObj/PrimObj on this data plane — that is the whole point of #76.\n${rawMarshallers}`
+            : undefined,
+        boxedMarshallers
+            ? `// Value-space output-assembly fallback (mustMarshal_*): reached ONLY when an output directly refs an\n// input param of a named type (a Value boundary read, not the row data plane). Off the de-box hot path.\n${boxedMarshallers}`
+            : undefined,
+        `// typed -> Value serializers (final return boundary only): canonical observation for the equivalence pin.\n${serializers}`,
+        `// must-form helpers reused for the output assembly (Value-space, off the row data plane).\n${mustHelpers}`,
+        arrOptNodeHelpers ? `// arr/opt node de-box helpers (Value-space output assembly).\n${arrOptNodeHelpers}` : undefined,
+        nodeMaterializers
+            ? `// scalar/arr/opt node RAW materializers: FAIL-CLOSED de-box (TYPE_MISMATCH/MISSING_PROP) from RawValue.\n${nodeMaterializers}`
+            : undefined,
+        `// RAW-ABI struct-native runners: the REAL de-box exec path (called by BindRaw).\n${runners}`,
+        bindRaw,
+    ];
+    const typedBody = sections.filter((s) => !!s).join("\n\n");
+    return `${straightlineCode.replace(/\n+$/, "\n")}\n${typedBody}\n`;
+}
+/**
+ * goRawAbiEmitter — language id `go-typed-raw` (bc#76). Emits the straight-line body (for
+ * untyped components / helpers) plus the RAW-ABI de-boxed layer (struct materialized directly
+ * from RawValue) and the BindRaw surface. Requires at least one outType/outputType annotation.
+ */
+export const goRawAbiEmitter = {
+    language: "go-typed-raw",
+    fileExtension: ".go",
+    defaultRuntimeImport: "github.com/foo-ogawa/behavior-contracts/go",
+    filenameHint: "behaviors.typed.raw.generated.go",
+    emit,
+};
+//# sourceMappingURL=emit-raw-abi-go.js.map

package/dist/generator/emit-raw-abi-go.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-raw-abi-go.js","sourceRoot":"","sources":["../../src/generator/emit-raw-abi-go.ts"],"names":[],"mappings":"AAsCA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,QAAQ,EAA8C,MAAM,YAAY,CAAC;AAChH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAGnE,MAAM,EACJ,GAAG,EACH,QAAQ,EACR,WAAW,EACX,aAAa,EACb,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,0BAA0B,EAC1B,cAAc,EACd,uBAAuB,EACvB,SAAS,EACT,wBAAwB,EACxB,qBAAqB,GACtB,GAAG,gBAAgB,CAAC;AAErB,4FAA4F;AAE5F,gEAAgE;AAChE,SAAS,kBAAkB,CAAC,IAAc;IACxC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IACvC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC3E,CAAC;AAED,SAAS,oBAAoB,CAAC,CAAW,EAAE,IAAc;IACvD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,IAAI,QAAQ,GAAG,eAAe,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC;IACnF,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAClC,wFAAwF;IACxF,8DAA8D;IAC9D,KAAK,CAAC,IAAI,CAAC,qBAAqB,GAAG,UAAU,CAAC,CAAC;IAC/C,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACzB,KAAK,CAAC,IAAI,CACR,mBAAmB,GAAG,uDAAuD,CAAC,CAAC,IAAI,yBAAyB,GAAG,qBAAqB,CACrI,CAAC;IACF,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClB,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACtC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClB,KAAK,CAAC,IAAI,CAAC,gCAAgC,MAAM,GAAG,CAAC,CAAC;QACtD,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAChC,KAAK,CAAC,IAAI,CACR,qBAAqB,GAAG,sDAAsD,CAAC,CAAC,IAAI,yBAAyB,MAAM,GAAG,CACvH,CAAC;QACF,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,OAAO,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAC5E,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAChC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,MAAc,EAAE,GAAW,EAAE,GAAY,EAAE,IAAc,EAAE,MAAc;IACxG,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9B,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC;QACjB,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;gBAC1B,oFAAoF;gBACpF,uFAAuF;gBACvF,OAAO,GAAG,CAAC,GAAG,MAAM,QAAQ,CAAC;YAC/B,CAAC;YACD,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAChC,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;YACpF,OAAO;gBACL,GAAG,CAAC,cAAc,GAAG,KAAK,EAAE,GAAG;gBAC/B,GAAG,CAAC,WAAW;gBACf,GAAG,CAAC,iBAAiB,GAAG,iEAAiE,GAAG,CAAC,MAAM,WAAW,GAAG,iBAAiB,GAAG,IAAI;gBACzI,GAAG,CAAC,GAAG;gBACP,GAAG,CAAC,GAAG,MAAM,OAAO;aACrB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC;QACD,KAAK,OAAO,CAAC,CAAC,CAAC;YACb,OAAO;gBACL,GAAG,CAAC,2BAA2B,GAAG,CAAC,IAAI,IAAI,GAAG,GAAG;gBACjD,GAAG,CAAC,kBAAkB;gBACtB,GAAG,CAAC,oBAAoB;gBACxB,GAAG,CAAC,GAAG;gBACP,GAAG,CAAC,GAAG,MAAM,OAAO;aACrB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC;QACD,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,KAAK,GAAG,uBAAuB,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;YACxF,OAAO;gBACL,GAAG,CAAC,eAAe,GAAG,OAAO,GAAG,YAAY;gBAC5C,GAAG,CAAC,WAAW;gBACf,GAAG,CAAC,iBAAiB,GAAG,4EAA4E,GAAG,iBAAiB,GAAG,IAAI;gBAC/H,GAAG,CAAC,GAAG;gBACP,GAAG,CAAC,mBAAmB,MAAM,gBAAgB;gBAC7C,GAAG,CAAC,+BAA+B;gBACnC,GAAG,CAAC,iBAAiB,MAAM,EAAE;gBAC7B,KAAK;gBACL,GAAG,CAAC,kCAAkC;gBACtC,GAAG,CAAC,GAAG;gBACP,GAAG,CAAC,GAAG,MAAM,UAAU;aACxB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC;QACD,KAAK,KAAK,CAAC,CAAC,CAAC;YACX,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,KAAK,GAAG,uBAAuB,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;YAClF,OAAO;gBACL,GAAG,CAAC,MAAM,GAAG,WAAW;gBACxB,GAAG,CAAC,KAAK,MAAM,QAAQ;gBACvB,GAAG,CAAC,UAAU;gBACd,GAAG,CAAC,gBAAgB,OAAO,EAAE;gBAC7B,KAAK;gBACL,GAAG,CAAC,KAAK,MAAM,YAAY;gBAC3B,GAAG,CAAC,GAAG;aACR,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACf,CAAC;IACH,CAAC;AACH,CAAC;AAED,wFAAwF;AACxF,SAAS,uBAAuB,CAAC,QAAgB,EAAE,MAAc;IAC/D,OAAO,sBAAsB,QAAQ,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,EAAE,CAAC;AAC7F,CAAC;AAED,SAAS,wBAAwB,CAAC,IAAe,EAAE,UAAgC,EAAE,IAAc;IACjG,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;QAC7C,IAAI,GAAG,CAAC,IAAI,KAAK,OAAO;YAAE,SAAS;QACnC,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,EAAE,GAAG,uBAAuB,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAClD,MAAM,IAAI,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACjE,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,EAAE,yBAAyB,EAAE,KAAK,IAAI,wBAAwB,CAAC,CAAC;IACjH,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC;AAED,yFAAyF;AAEzF,MAAM,UAAU,GAAG,aAAa,CAAC;AAEjC,SAAS,gBAAgB,CAAC,MAAc,EAAE,OAAe,EAAE,GAAwB,EAAE,QAAgB,EAAE,MAAc,EAAE,YAAoC;IACzJ,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC9B,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,OAAO,OAAO,EAAE,CAAC;IACnD,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC;IACpD,MAAM,KAAK,GAAG,GAAG,CAAC,mBAAmB,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,QAAQ,IAAI,KAAK,CAAC,kBAAkB,CAAC;IAChG,MAAM,IAAI,GACR,GAAG,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,eAAe,GAAG,CAAC,IAAI,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,OAAO,GAAG,CAAC;IAC5H,OAAO,GAAG,CAAC,eAAe,IAAI,KAAK,CAAC,qBAAqB,CAAC,8BAA8B,CAAC,MAAM,KAAK,EAAE,CAAC;AACzG,CAAC;AAED,SAAS,kBAAkB,CAAC,IAAe;IACzC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,KAAK,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YAC9B,MAAM,EAAE,GAAI,CAAgC,CAAC,OAAO,CAAC;YACrD,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;gBACrB,MAAM,IAAI,gBAAgB,CACxB,+BAA+B,EAC/B,kCAAkC,IAAI,CAAC,IAAI,WAAY,CAAoB,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,2OAA2O,CACrW,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,EAAgE,EAAE,QAAgB,EAAE,UAAgC,EAAE,IAAc,EAAE,YAAoC;IAChM,IAAI,EAAE,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;QAC/B,gFAAgF;QAChF,2EAA2E;QAC3E,MAAM,IAAI,gBAAgB,CACxB,+BAA+B,EAC/B,6BAA6B,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,IAAI,iFAAiF,CACtI,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,GAAG,SAAS,CAAC;IACrB,MAAM,SAAS,GAAG,EAAE,CAAC,KAAK;SACvB,GAAG,CACF,CAAC,CAAC,EAAE,EAAE,CACJ,SAAS,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI;;;;kBAI3B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CACrD;SACA,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,MAAM,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;IAC3D,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAClC,MAAM,WAAW,GAAG,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC;IAC1F,OAAO,eAAe,EAAE,CAAC,KAAK;iBACf,GAAG,YAAY,IAAI;6BACP,GAAG,6BAA6B,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC;;4BAEvF,GAAG,wDAAwD,EAAE,CAAC,SAAS;;;iBAGlF,GAAG;;EAElB,WAAW;eACE,GAAG;MACZ,CAAC;AACP,CAAC;AAED,SAAS,aAAa,CAAC,IAAe,EAAE,IAAc;IACpD,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACzB,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,0BAA0B,CAAC,IAAI,CAAC,CAAC;IAC/C,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAEjD,MAAM,KAAK,GAAG,CAAC,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC;SACpC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,SAAS,UAAU,CAAC,EAAE,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;SACnE,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,MAAM,YAAY,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,cAAc,EAAE,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,EAAE,CAAC;IACvF,MAAM,aAAa,GAAG,CAAC,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;SACzC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,YAAY,CAAC,EAAE,CAAC,oBAAoB,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC;SACxE,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,sFAAsF;IACtF,mFAAmF;IACnF,MAAM,uBAAuB,GAAG,CAAC,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC;SACtD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE;QACjB,MAAM,GAAG,GAAG,cAAc,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;QACtD,OAAO,UAAU,YAAY,CAAC,EAAE,CAAC,mBAAmB,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,GAAG,UAAU,CAAC;IAC3F,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;IAEd,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7G,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,0BAA0B,CAAC;IAExG,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAChG,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;IAClE,MAAM,WAAW,GAAG,GAAG,CAAC,GAAG,IAAI,MAAM,CAAC;IACtC,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,aAAa,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC;IAElG,OAAO,oBAAoB,EAAE;;;;;;qBAMV,EAAE,aAAa,GAAG,6BAA6B,GAAG,UAAU,GAAG;WACzE,cAAc,CAAC,KAAK,CAAC;;cAElB,GAAG;;EAEf,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE;;yBAE9C,GAAG;WACjB,GAAG;;;;EAIZ,uBAAuB,CAAC,CAAC,CAAC,sBAAsB,GAAG,uBAAuB,GAAG,0BAA0B,CAAC,CAAC,CAAC,EAAE;;;;sCAIxE,GAAG;;aAE5B,GAAG;;oBAEI,GAAG,cAAc,GAAG,WAAW,GAAG;;;;;;;;;EASpD,IAAI;wBACkB,GAAG;;YAEf,WAAW;gBACP,GAAG;mBACA,GAAG;;;;;;;mBAOH,GAAG,CAAC,IAAI;;WAEhB,UAAU;EACnB,CAAC;AACH,CAAC;AAED,yFAAyF;AAEzF,SAAS,WAAW,CAAC,GAAgB;IACnC,MAAM,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC,UAAU;SAC3B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC5B,OAAO,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,GAAG,UAAU,GAAG,8CAA8C,EAAE,wBAAwB,CAAC;IAClJ,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,OAAO;;;wBAGe,GAAG,uCAAuC,GAAG,UAAU,GAAG;0BACxD,GAAG,UAAU,GAAG;EACxC,IAAI;;EAEJ,CAAC;AACH,CAAC;AAED,wFAAwF;AAExF,SAAS,IAAI,CAAC,GAAgB;IAC5B,MAAM,KAAK,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC;IACxC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,gBAAgB,CACxB,+BAA+B,EAC/B,oIAAoI,CACrI,CAAC;IACJ,CAAC;IACD,0FAA0F;IAC1F,yFAAyF;IACzF,wBAAwB,CAAC,IAAI,CAAC,CAAC;IAC/B,MAAM,gBAAgB,GAAG,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACzD,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAEhC,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACnC,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,cAAc,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IAC1C,6FAA6F;IAC7F,8FAA8F;IAC9F,2FAA2F;IAC3F,wFAAwF;IACxF,MAAM,gBAAgB,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;IAC/C,MAAM,WAAW,GAAG,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC3D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,qBAAqB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IAC5E,MAAM,iBAAiB,GAAG,GAAG,CAAC,EAAE,CAAC,UAAU;SACxC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;QACT,MAAM,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAC;QAC9C,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,KAAK,IAAI,CAAC;gBAAE,SAAS;YACzB,MAAM,EAAE,GAAI,CAAgC,CAAC,OAAO,CAAC;YACrD,IAAI,EAAE,KAAK,SAAS;gBAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,aAAa,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC;QACtE,CAAC;QACD,OAAO,wBAAwB,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;IACvD,CAAC,CAAC;SACD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SAC3B,IAAI,CAAC,MAAM,CAAC,CAAC;IAChB,MAAM,OAAO,GAAG,GAAG,CAAC,EAAE,CAAC,UAAU;SAC9B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;SAClC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChB,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAEjC,MAAM,MAAM,GAAG;;;;yGAIwF,CAAC;IACxG,MAAM,QAAQ,GAA2B;QACvC,MAAM;QACN,KAAK,IAAI,SAAS;QAClB,cAAc;YACZ,CAAC,CAAC,4LAA4L,cAAc,EAAE;YAC9M,CAAC,CAAC,SAAS;QACb,gBAAgB;YACd,CAAC,CAAC,oNAAoN,gBAAgB,EAAE;YACxO,CAAC,CAAC,SAAS;QACb,+GAA+G,WAAW,EAAE;QAC5H,+FAA+F,WAAW,EAAE;QAC5G,iBAAiB,CAAC,CAAC,CAAC,kEAAkE,iBAAiB,EAAE,CAAC,CAAC,CAAC,SAAS;QACrH,iBAAiB;YACf,CAAC,CAAC,6GAA6G,iBAAiB,EAAE;YAClI,CAAC,CAAC,SAAS;QACb,qFAAqF,OAAO,EAAE;QAC9F,OAAO;KACR,CAAC;IACF,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxE,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC;AACrE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAkB;IAC5C,QAAQ,EAAE,cAAc;IACxB,aAAa,EAAE,KAAK;IACpB,oBAAoB,EAAE,4CAA4C;IAClE,YAAY,EAAE,kCAAkC;IAChD,IAAI;CACL,CAAC"}

package/dist/generator/emit-raw-abi-rust.d.ts

@@ -0,0 +1,45 @@
+/**
+ * emit-raw-abi-rust.ts — Rust RAW handler ABI emitter (bc#76): the de-boxed typed path.
+ *
+ * # What this replaces
+ *
+ * The boxed typed emitter (emit-straightline-typed-rust.ts) generates
+ * `marshal_T*(raw: &Value) -> Result<T*, BehaviorError>`: the handler builds a full dynamic
+ * `Value::Obj` tree and the marshaller WALKS it into a struct — a Value->struct conversion
+ * LAYERED on top of boxing. Rust felt the residual ~22% gap #75 measured most: the `Value`
+ * enum heap-boxes every `Obj` pair into `Vec<(String, Value)>`, cloned at the ABI, re-walked.
+ *
+ * # What this emits
+ *
+ * A RAW module that materializes structs DIRECTLY from a `RawValue` (native-backed, NOT a
+ * `Value` — see rust/src/rawabi.rs). The generated code:
+ *
+ *   - `marshal_raw_T*(raw: &RawValue) -> Result<T*, BehaviorError>`: matches on RawValue
+ *     (scalar / RawRow / Arr) straight into the concrete struct. It NEVER constructs a
+ *     `Value::Obj`/`Value` on the row data plane.
+ *   - `run_typed_raw_<comp><H: RawComponentExec>(handlers, input) -> Result<Value, ...>`:
+ *     drives the plan with the run_plan primitive (plan SSoT, reused), evaluates ports with
+ *     the native/primitive straight-line expressions (unchanged — ports are Value-space, off
+ *     the row data plane), calls the RAW handler (`exec_raw_ctx` -> `RawValue`), and
+ *     materializes the node struct via `marshal_raw_T*` at the boundary. The output is
+ *     assembled as a struct and serialized to a Value ONLY at the final return boundary (the
+ *     equivalence pin), exactly as the boxed typed path — so the OBSERVED result equals
+ *     run_behavior while the row data plane never boxed.
+ *   - `bind_raw<H: RawComponentExec>(handlers) -> BoundRaw<H>` + `BoundRaw::call`: the raw
+ *     dispatch surface (mirrors bind/Bound::call). `COMPONENT_NAMES_RAW` lists the typed
+ *     components exposed on the raw path.
+ *
+ * # Scope
+ *
+ * The raw de-box covers the componentRef read-handler shape (graphddb's row hydrator). Typed
+ * map/cond nodes LOUD-fail (UNSUPPORTED_NODE_STRAIGHTLINE) so a consumer regenerates those on
+ * the boxed typed path rather than getting a module that silently re-boxes.
+ */
+import type { EmitterPlugin } from "./core.js";
+/**
+ * rustRawAbiEmitter — language id `rust-typed-raw` (bc#76). Emits the straight-line body (for
+ * untyped components / helpers) plus the RAW-ABI de-boxed layer (struct materialized directly from
+ * RawValue) and the bind_raw surface. Requires at least one outType/outputType annotation.
+ */
+export declare const rustRawAbiEmitter: EmitterPlugin;
+//# sourceMappingURL=emit-raw-abi-rust.d.ts.map

package/dist/generator/emit-raw-abi-rust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-raw-abi-rust.d.ts","sourceRoot":"","sources":["../../src/generator/emit-raw-abi-rust.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AA8a5D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAM/B,CAAC"}