behavior-contracts 0.4.0 → 0.5.0

package/dist/generator/emit-straightline-native-go.d.ts

@@ -0,0 +1,54 @@
+/**
+ * emit-straightline-native-go.ts — Go NATIVE-PORTS straight-line emitter (bc 0.5.0).
+ *
+ * # What this removes (the generic key-value plumbing on the PORT plane)
+ *
+ * The straight-line emitter (emit-straightline-go.ts) builds, per componentRef node, a
+ * GENERIC key-value port container:
+ *
+ *     ports_row := dslcontracts.NewObj()              // a map[string]Value alloc
+ *     pv_row_PK := slBindVE(input, "pk")              // slVE{Val,Err} wrapper
+ *     if pv_row_PK.Err != nil { return nil, ... }     // (dead branch for infallible ports)
+ *     ports_row.Set("PK", pv_row_PK.Val)              // boxed Value insert into the map
+ *     o_row, _ := dslcontracts.ExecHandler(handlers, "row", "GetItem", ports_row, nil) // generic dispatch
+ *
+ * Measured (go1.26): NewObj()+3×Set == ~326 ns/op + 6 allocs/op — essentially the ENTIRE
+ * cost of a single-op straight-line component (~335 ns/op). That generic key-value container
+ * is the residual "遅い処理" that made a single-op point read tie/lose the ir interpreter.
+ *
+ * # What this emits (native ports struct + native handler entry)
+ *
+ *     type portsGetItem_row struct { Table, PK, SK string }  // typed per the port's static type
+ *     func (p portsGetItem_row) Port(name string) (dslcontracts.Value, bool) { ... }  // PortReader
+ *     ...
+ *     pkS, ok := input.Get("pk"); if !ok { return nil, UNKNOWN_BINDING }  // a fallible port: direct return
+ *     ports := portsGetItem_row{Table: "Items", PK: pkS, SK: skS}         // ZERO map alloc, ZERO boxing
+ *     outcome, resolved := dslcontracts.ExecNativeHandler(handlers, "row", "GetItem", ports, nil)
+ *
+ * Statically-typed ports (string/int/float/bool derivable from a literal / concat / a ref to a
+ * typed input param) become typed struct fields assigned directly — no slVE wrapper, no dead
+ * error branch. A port whose type is genuinely dynamic keeps a `dslcontracts.Value` field (one
+ * boxed leaf, still no map). Fallible ports (a ref that can UNKNOWN_BINDING / a concat that can
+ * TYPE_MISMATCH) keep their error path as a DIRECT return (not an slVE wrapper struct).
+ *
+ * Fail-closed operator semantics are unchanged: overflow/short-circuit/type errors still route
+ * through the A0 primitives (the dynamic port path calls emitExpr = the primitive SSoT). Only
+ * the port CONTAINER + dispatch go native.
+ *
+ * # Scope (additive)
+ *
+ * Covers strictly-sequential componentRef components (sequentialOrder != null, no map/cond
+ * body node). map/cond/real-concurrency components fall through to the generic straight-line
+ * body (emitted alongside, byte-identical) — BindNative binds only the native-covered
+ * components; a consumer keeps the rest on the generic Bind. This mirrors go-typed-raw's
+ * additive discipline. The literal/ir endpoint and the generic Bind are UNCHANGED.
+ */
+import type { EmitterPlugin } from "./core.js";
+/**
+ * goStraightlineNativeEmitter — language id `go-straightline-native` (bc 0.5.0). Emits the
+ * generic straight-line body (fallback + helpers) plus the NATIVE-PORTS layer (per-node ports
+ * struct built by direct assignment + BindNative through the native handler seam). Additive:
+ * the generic Bind / literal / ir endpoints are unchanged.
+ */
+export declare const goStraightlineNativeEmitter: EmitterPlugin;
+//# sourceMappingURL=emit-straightline-native-go.d.ts.map

package/dist/generator/emit-straightline-native-go.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit-straightline-native-go.d.ts","sourceRoot":"","sources":["../../src/generator/emit-straightline-native-go.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,WAAW,CAAC;AAs3B5D;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,EAAE,aAMzC,CAAC"}