behavior-contracts 0.1.3 → 0.2.1

package/dist/authoring.js

@@ -0,0 +1,787 @@
+import { SPEC_VERSIONS } from "./index.js";
+import { assertPortableComponentGraph } from "./guard.js";
+import { buildComponentCore, checkPortableEntry, checkPortNames, checkDeclaredPortTypes, collectNodeIdRefs, DEFAULT_PLAN_CONCURRENCY, } from "./builder.js";
+export class AuthoringFailure extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "AuthoringFailure";
+    }
+}
+function afail(code, message) {
+    throw new AuthoringFailure(code, message);
+}
+// ── root マーカー（クラス単位・effect 非依存）───────────────────────────────────
+const BEHAVIOR_MARK = /* @__PURE__ */ Symbol.for("behavior-contracts.authoring.behavior");
+/**
+ * `SemanticBehavior` — 共有 authoring の基底クラス（既定の root マーカー）。
+ * 継承したクラスの各 public メソッドが 1 root Behavior として publish される。
+ * マーカー以外の実装・状態は持たない（authoring は effect 非依存・宣言のみ）。
+ */
+export class SemanticBehavior {
+}
+/**
+ * `@behavior` — クラスデコレータ形の root マーカー（`SemanticBehavior` 継承と**同義**。
+ * 同じクラス本体はどちらのマーカーでも同一 IR に lower される）。
+ * TC39 standard / legacy いずれのデコレータ位置でも、素の関数呼び出しでも使える。
+ */
+export function behavior(cls, _context) {
+    Object.defineProperty(cls, BEHAVIOR_MARK, { value: true, configurable: true });
+    return cls;
+}
+function isBehaviorClass(cls) {
+    if (typeof cls !== "function")
+        return false;
+    if (cls[BEHAVIOR_MARK] === true)
+        return true;
+    return cls === SemanticBehavior || cls.prototype instanceof SemanticBehavior;
+}
+// ── recorder（式 Proxy）─────────────────────────────────────────────────────────
+const EXPR_META = /* @__PURE__ */ Symbol("behavior-contracts.authoring.expr");
+/** recorder 値なら ExprMeta を返す。 */
+function exprMetaOf(v) {
+    if (v === null || (typeof v !== "object" && typeof v !== "function"))
+        return undefined;
+    return v[EXPR_META];
+}
+function makeExpr(meta) {
+    return new Proxy({}, {
+        get(_t, prop) {
+            if (prop === EXPR_META)
+                return meta;
+            if (typeof prop === "symbol") {
+                if (prop === Symbol.toPrimitive)
+                    return () => notRecordable("implicit coercion of a recorded value (use concat/add/eq/... builders)");
+                return undefined;
+            }
+            // Promise-likeness / util.inspect の誤爆を避ける（record 対象でもない）。
+            if (prop === "then" || prop === "constructor" || prop === "inspect")
+                return undefined;
+            if (prop === "valueOf" || prop === "toString" || prop === "toJSON")
+                return () => notRecordable(`'${prop}' on a recorded value (implicit coercion is not statically interpretable)`);
+            if (prop === "map")
+                return (cb, opts) => recordMap(meta, cb, opts);
+            if (meta.refPath === null)
+                afail("COMPUTED_ACCESS", `property '.${prop}' on a computed expression cannot be lowered (bind the value through a component result or restructure the wiring)`);
+            if (meta.isInput && meta.refPath.length === 0)
+                recordInputPort(prop);
+            const path = [...meta.refPath, prop];
+            return makeExpr({ node: { [meta.refOp]: path }, refPath: path, refOp: meta.refOp, isInput: meta.isInput });
+        },
+        ownKeys() {
+            return notRecordable("spread / enumeration of a recorded value (Expression IR has no object-merge operator; wire explicit keys)");
+        },
+        getOwnPropertyDescriptor() {
+            return notRecordable("property enumeration of a recorded value");
+        },
+        set() {
+            return notRecordable("assignment into a recorded value (authoring is declarative)");
+        },
+    });
+}
+function notRecordable(what) {
+    afail("NOT_RECORDABLE", `not statically interpretable: ${what}`);
+}
+/** 演算結果（ref path を持たない）recorder。 */
+function opExpr(node) {
+    return makeExpr({ node, refPath: null, refOp: "ref", isInput: false });
+}
+/** ノード結果 recorder（`{ref:[<nodeId>]}` root。プロパティアクセスで path 延長可能）。 */
+function nodeHandle(id) {
+    return makeExpr({ node: { ref: [id] }, refPath: [id], refOp: "ref", isInput: false });
+}
+// ── 値 → Expression IR lowering ────────────────────────────────────────────────
+/**
+ * authoring 本体に現れた値を Expression IR へ lower する。
+ * recorder はその IR ノードに、リテラルはそのまま（配列 → `{arr:[...]}`、オブジェクト →
+ * `{obj:{...}}`、bigint → `{int:"..."}`）に落ちる。関数 / Date / Promise / undefined は
+ * Portability 違反として loud に失敗する（fail-closed）。
+ */
+function lowerValue(v, at) {
+    const meta = exprMetaOf(v);
+    if (meta) {
+        if (meta.refPath !== null && meta.refPath.length === 0)
+            afail("WHOLE_INPUT", `${at}: the whole '$' input cannot be wired; reference a field of it`);
+        return meta.node;
+    }
+    if (v === null)
+        return null;
+    switch (typeof v) {
+        case "boolean":
+        case "string":
+            return v;
+        case "number":
+            if (Number.isInteger(v) && !Number.isSafeInteger(v))
+                afail("BAD_PORT_VALUE", `${at}: integral literal ${v} exceeds the safe range (use a bigint literal)`);
+            if (!Number.isFinite(v))
+                afail("BAD_PORT_VALUE", `${at}: non-finite number literal`);
+            return v;
+        case "bigint":
+            return { int: v.toString() };
+        case "undefined":
+            afail("BAD_PORT_VALUE", `${at}: undefined cannot be wired`);
+            break;
+        case "function":
+            afail("BAD_PORT_VALUE", `${at}: functions cannot be placed in IR (Portability Guard)`);
+            break;
+    }
+    if (Array.isArray(v))
+        return { arr: v.map((e, i) => lowerValue(e, `${at}[${i}]`)) };
+    if (v instanceof Date || v instanceof Promise)
+        afail("BAD_PORT_VALUE", `${at}: ${v.constructor.name} cannot be placed in IR (Portability Guard)`);
+    if (typeof v === "object") {
+        const out = {};
+        for (const k of Object.keys(v)) {
+            if (k === "__proto__")
+                afail("BAD_PORT_VALUE", `${at}: object key "__proto__" is forbidden (fail-closed)`);
+            out[k] = lowerValue(v[k], `${at}.${k}`);
+        }
+        return { obj: out };
+    }
+    afail("BAD_PORT_VALUE", `${at}: value cannot be wired`);
+}
+// ── Expression builders（expression-ir.md §3 の閉集合と 1:1）──────────────────────
+function binOp(op) {
+    return (a, b) => opExpr({ [op]: [lowerValue(a, op), lowerValue(b, op)] });
+}
+function unOp(op) {
+    return (a) => opExpr({ [op]: [lowerValue(a, op)] });
+}
+/** `+`（文字列連結）。n-ary（min 2）。 */
+export function concat(...parts) {
+    if (parts.length < 2)
+        afail("BAD_PORT_VALUE", `concat expects >= 2 args, got ${parts.length}`);
+    return opExpr({ concat: parts.map((p, i) => lowerValue(p, `concat[${i}]`)) });
+}
+export const add = /* @__PURE__ */ binOp("add");
+export const sub = /* @__PURE__ */ binOp("sub");
+export const mul = /* @__PURE__ */ binOp("mul");
+export const div = /* @__PURE__ */ binOp("div");
+export const mod = /* @__PURE__ */ binOp("mod");
+export const neg = /* @__PURE__ */ unOp("neg");
+export const eq = /* @__PURE__ */ binOp("eq");
+export const ne = /* @__PURE__ */ binOp("ne");
+export const lt = /* @__PURE__ */ binOp("lt");
+export const le = /* @__PURE__ */ binOp("le");
+export const gt = /* @__PURE__ */ binOp("gt");
+export const ge = /* @__PURE__ */ binOp("ge");
+export const and = /* @__PURE__ */ binOp("and");
+export const or = /* @__PURE__ */ binOp("or");
+export const not = /* @__PURE__ */ unOp("not");
+/** `??`。 */
+export const coalesce = /* @__PURE__ */ binOp("coalesce");
+export const len = /* @__PURE__ */ unOp("len");
+/**
+ * `opt(x)` — `?.`（optional chaining）の record 形。ref recorder を refOpt に変換する
+ * （以降のプロパティアクセスは中間 null で null を返す — expression-ir.md `refOpt`）。
+ */
+export function opt(x) {
+    const meta = exprMetaOf(x);
+    if (!meta || meta.refPath === null || meta.refPath.length === 0)
+        afail("BAD_PORT_VALUE", "opt(...) expects a reference (a recorded '$' field or node result)");
+    return makeExpr({ node: { refOpt: meta.refPath }, refPath: meta.refPath, refOp: "refOpt", isInput: meta.isInput });
+}
+let currentFrame = null;
+function requireFrame(what) {
+    if (!currentFrame)
+        afail("NO_FRAME", `${what} was used outside compileBehaviors() (recorders only work during build-time evaluation)`);
+    return currentFrame;
+}
+function recordInputPort(name) {
+    const f = requireFrame(`$.${name}`);
+    if (!f.inputPorts.has(name))
+        f.inputPorts.set(name, { type: "unknown", required: true });
+}
+function nextId(f) {
+    const id = `n${f.seq++}`;
+    f.nodeIds.add(id);
+    return id;
+}
+/** 分岐スタックの条件を `and` 連鎖に合成する（gate の `if`）。 */
+function composedCond(f) {
+    const conds = f.branchStack.map((b) => b.cond);
+    return conds.reduce((acc, c) => (acc === undefined ? c : { and: [acc, c] }), undefined);
+}
+/**
+ * 分岐内に Component が初めて現れた時点で gate（CondNode）を遅延生成する。
+ * gate は条件成立時 `{ok:true}` / 不成立時 `null` を返し、分岐内ノードは
+ * `parent=gate, bindField:"ok"` の null-binding skip（execution-plan.md）で実行選択される。
+ */
+function ensureGate(f) {
+    const bf = f.branchStack[f.branchStack.length - 1];
+    if (!bf)
+        return null;
+    if (f.branchStack.length > 1)
+        afail("NESTED_BRANCH", `method '${f.method}': a when(...) branch containing components cannot nest inside another when(...) branch (authoring v1; flatten to sibling gates)`);
+    if (bf.gateId === null) {
+        const id = nextId(f);
+        const gate = { id, cond: { if: composedCond(f), then: { obj: { ok: true } }, else: null } };
+        f.nodes.push(gate);
+        bf.gateId = id;
+    }
+    return bf;
+}
+/** ports の deps から parent（Wire）を決める: in-branch データ親 > gate > 先頭データ親。 */
+function chooseParent(f, deps, bf) {
+    if (bf) {
+        const inBranch = deps.find((d) => {
+            const idx = f.nodes.findIndex((n) => n.id === d);
+            return idx >= bf.startLen;
+        });
+        if (inBranch !== undefined)
+            return { parent: inBranch }; // gate skip は親経由で伝播する
+        return { parent: bf.gateId, bindField: "ok" };
+    }
+    if (deps.length > 0)
+        return { parent: deps[0] };
+    return {};
+}
+// ── Catalog → component 関数（leaf 呼び出しの record）──────────────────────────────
+/**
+ * catalogComponents — consumer の Catalog から、authoring 本体で呼べる leaf コンポーネント
+ * 関数群を作る（C2: consumer が供給するのはこの Catalog だけ）。
+ *
+ * 各関数は `Component({ port: <expr | literal> })` の呼び出しを componentRef ノードとして
+ * record し、ノード結果の recorder（後続配線・`.map`・Output 参照に使える）を返す。
+ * Port は catalog の Port schema に対して build-time 検証される（未知 Port / required 欠落は
+ * fail-closed）。`portableToIR: false` のエントリは可搬 IR に載らないため拒否する。
+ */
+export function catalogComponents(catalog) {
+    const out = {};
+    for (const name of Object.keys(catalog)) {
+        const entry = catalog[name];
+        out[name] = (ports) => recordComponentCall(name, entry, ports);
+    }
+    return out;
+}
+function recordComponentCall(name, entry, portsIn) {
+    const f = requireFrame(`component '${name}'`);
+    checkPortableEntry(name, entry, afail);
+    if (!portsIn || typeof portsIn !== "object" || Array.isArray(portsIn) || exprMetaOf(portsIn))
+        afail("BAD_PORT_VALUE", `component '${name}': ports must be a plain object literal`);
+    // Port schema 検証（build-time・fail-closed。builder.ts のデータ登録経路と共有 — B-3）:
+    // 未宣言 Port（additionalPorts ポリシー）・required 欠落、lower 後に宣言 Port の
+    // スカラリテラル型。
+    checkPortNames(name, entry, Object.keys(portsIn), afail);
+    const ports = {};
+    for (const k of Object.keys(portsIn))
+        ports[k] = lowerValue(portsIn[k], `component '${name}' port '${k}'`);
+    checkDeclaredPortTypes(name, entry, ports, afail);
+    // map コールバック内 → MapNode の component/ports として capture（単一静的ノード）。
+    if (f.pendingMap) {
+        if (f.pendingMap.component !== null)
+            afail("MAP_MULTI_COMPONENT", `method '${f.method}': a .map callback must invoke exactly one component (got a second call: '${name}')`);
+        f.pendingMap.component = name;
+        f.pendingMap.ports = ports;
+        // callback 内でこの要素結果へさらに配線することはできない（record は構造のみ）。
+        return opExpr(null);
+    }
+    const bf = ensureGate(f);
+    const deps = collectNodeIdRefs(ports, f.nodeIds);
+    const id = nextId(f);
+    const wire = chooseParent(f, deps, bf);
+    const node = { id, component: name, ports };
+    if (wire.parent !== undefined)
+        node.parent = wire.parent;
+    if (wire.bindField !== undefined)
+        node.bindField = wire.bindField;
+    f.nodes.push(node);
+    return nodeHandle(id);
+}
+// ── structured control: Map（ネイティブ `.map` を lower）───────────────────────────
+function recordMap(overMeta, cb, opts) {
+    const f = requireFrame(".map");
+    if (f.pendingMap)
+        afail("NESTED_MAP", `method '${f.method}': nested .map is not in the v2 vocabulary (chain a second map over the augmented list — scp-ir-architecture.md §5.1)`);
+    if (f.branchStack.length > 0)
+        afail("MAP_IN_BRANCH", `method '${f.method}': .map inside a when(...) branch is not expressible in the IR (guard the 'over' expression instead)`);
+    if (typeof cb !== "function")
+        afail("MAP_NOT_LOWERABLE", `method '${f.method}': .map expects an inline arrow callback`);
+    if (cb.length > 1)
+        afail("MAP_NOT_LOWERABLE", `method '${f.method}': .map callback takes exactly one element binding (v1)`);
+    if (overMeta.refPath !== null && overMeta.refPath.length === 0)
+        afail("WHOLE_INPUT", `method '${f.method}': the whole '$' input cannot be iterated; reference an array field`);
+    if (opts !== undefined) {
+        if (opts === null || typeof opts !== "object")
+            afail("MAP_NOT_LOWERABLE", ".map options must be an object");
+        if (opts.into !== undefined && typeof opts.into !== "string")
+            afail("MAP_NOT_LOWERABLE", ".map option 'into' must be a string key");
+        if (opts.batched !== undefined && typeof opts.batched !== "boolean")
+            afail("MAP_NOT_LOWERABLE", ".map option 'batched' must be a boolean");
+    }
+    const as = `$e${f.mapSeq++}`;
+    const binding = makeExpr({ node: { ref: [as] }, refPath: [as], refOp: "ref", isInput: false });
+    f.pendingMap = { as, component: null, ports: null, when: undefined };
+    let pm;
+    try {
+        cb(binding);
+    }
+    finally {
+        pm = f.pendingMap;
+        f.pendingMap = null;
+    }
+    if (pm.component === null)
+        afail("MAP_NOT_LOWERABLE", `method '${f.method}': a .map callback must invoke a catalog component (a pure-transform map has no operator in the portable Expression IR v2 vocabulary)`);
+    const over = overMeta.node;
+    const deps = collectNodeIdRefs(over, f.nodeIds);
+    collectNodeIdRefs(pm.ports, f.nodeIds, deps);
+    if (pm.when !== undefined)
+        collectNodeIdRefs(pm.when, f.nodeIds, deps);
+    const id = nextId(f);
+    const node = {
+        id,
+        map: { over, as, component: pm.component, ports: pm.ports },
+    };
+    if (pm.when !== undefined)
+        node.map.when = pm.when;
+    if (opts?.into !== undefined)
+        node.map.into = opts.into;
+    if (opts?.batched === true)
+        node.map.batched = true;
+    if (deps.length > 0)
+        node.map.parent = deps[0];
+    f.nodes.push(node);
+    return nodeHandle(id);
+}
+// ── structured control: Conditional / Guard（`?:` / `&&` を lower）──────────────────
+/**
+ * when — Conditional（`?:`）/ Guard（`&&`）の record 形（semantic-contract-programming.md
+ * 「構造化制御構文」の Compiler 規則を評価モードで実装する）:
+ *
+ *   - 両分岐（else 省略時は then のみ）が**純式のみ** → Expression IR `{cond:[c,t,e]}` へ
+ *     inline lower（body ノードは増えない。else 省略は `null`）。
+ *   - 分岐に **Component 宣言を含む** → 分岐ごとに gate（CondNode + null-binding skip）を
+ *     立て、両分岐が値を持つ場合は Φ（CondNode）ノードで合流する（採用側のみ実行される）。
+ *     Guard 形（else 無し）は then の値をそのまま返す — 条件不成立時は当該ノードが Skip され、
+ *     下流へは未生成 Port の Skip 伝播規則で連鎖する。
+ *   - `.map` コールバック内では **per-element guard**（v2 `map.when`）として record される
+ *     （guard 形のみ。false の要素は handler 未呼び出しで結果から除外）。
+ *
+ * 条件は recorder 式でなければならない（ネイティブ `===` / `&&` の結果は record できない —
+ * eq/and/... builder を使う）。
+ */
+export function when(condition, then, otherwise) {
+    const f = requireFrame("when");
+    if (!exprMetaOf(condition))
+        afail("BAD_CONDITION", `method '${f.method}': when(...) condition must be a recorded expression (native ===/&&/?: over recorded values cannot be observed at build time — use eq/ne/and/... builders)`);
+    if (typeof then !== "function" || (otherwise !== undefined && typeof otherwise !== "function"))
+        afail("BAD_BRANCH", `method '${f.method}': when(...) branches must be thunks (() => ...)`);
+    const c = lowerValue(condition, "when condition");
+    // map コールバック内: per-element guard（v2 map.when）。
+    if (f.pendingMap) {
+        if (otherwise !== undefined)
+            afail("BAD_BRANCH", `method '${f.method}': when(...) inside a .map callback is guard-form only (no else — v2 'map.when' skips the element)`);
+        const before = f.pendingMap.component;
+        const result = then();
+        if (f.pendingMap.component === before) {
+            // 純式 guard → inline cond（else は null）。
+            return opExpr({ cond: [c, lowerValue(result, "when then"), null] });
+        }
+        if (f.pendingMap.when !== undefined)
+            afail("BAD_CONDITION", `method '${f.method}': a .map callback records at most one when(...) guard`);
+        f.pendingMap.when = c;
+        return result;
+    }
+    // then 分岐。
+    const thenFrame = { cond: c, gateId: null, startLen: f.nodes.length };
+    f.branchStack.push(thenFrame);
+    let thenVal;
+    try {
+        thenVal = then();
+    }
+    finally {
+        f.branchStack.pop();
+    }
+    const thenHasComponents = f.nodes.length > thenFrame.startLen;
+    // else 分岐。
+    let elseVal = null;
+    let elseHasComponents = false;
+    if (otherwise !== undefined) {
+        const elseFrame = { cond: { not: [c] }, gateId: null, startLen: f.nodes.length };
+        f.branchStack.push(elseFrame);
+        try {
+            elseVal = otherwise();
+        }
+        finally {
+            f.branchStack.pop();
+        }
+        elseHasComponents = f.nodes.length > elseFrame.startLen;
+    }
+    // 純式のみ → Expression IR へ inline lower（Compiler 規則）。
+    if (!thenHasComponents && !elseHasComponents)
+        return opExpr({ cond: [c, lowerValue(thenVal, "when then"), lowerValue(elseVal, "when else")] });
+    // Guard 形（else 無し）: then の値をそのまま返す（不成立時は gate skip → 未生成 Port）。
+    if (otherwise === undefined)
+        return thenVal;
+    // Φ 合流ノード: 採用側の値を単一 Port にする（cond は採用側のみ評価する）。
+    const id = nextId(f);
+    const phi = {
+        id,
+        cond: { if: c, then: lowerValue(thenVal, "when then"), else: lowerValue(elseVal, "when else") },
+    };
+    f.nodes.push(phi);
+    return nodeHandle(id);
+}
+// ── source scan（NATIVE_CONTROL_SYNTAX — bc#24 audit fix）───────────────────────────
+/**
+ * JS Proxy には ToBoolean / strict-equality のトラップが存在しないため、recorder 値上の
+ * ネイティブ制御構文は評価モードでは観測できず、黙って誤った DAG に lower され得る
+ * （`$.flag ? C.Get(..) : C.Put(..)` → 無条件 Get、`$.flag && C.Get(..)` → ガード消失、
+ * `$.limit ?? "d"` → default 消失、`!$.flag` → リテラル false、`if ($.flag) {..}` →
+ * then 側のみ、`switch ($.x)` → default 側のみ）。evaluation-mode recording に内在する
+ * 制約であり Proxy では塞げないため、**compileBehaviors は評価の前にソースを走査**して
+ * これらのトークンを一律 fail-closed で拒否する。
+ *
+ * 前処理（偽陽性の回避）: 文字列リテラルの内容・テンプレートリテラルのテキスト部
+ * （`${...}` 内の式コードは保持）・コメント・正規表現リテラル本体を空白化してから走査する。
+ * 走査対象はソースの最初の `{` 以降（= 本体）。ランタイムの `Function.prototype.toString`
+ * は型消去後のソースを返すため、TS の型レベル `?`（optional param / conditional type）は
+ * 現れない。パラメータ既定値はビルド時に実行されるコードなので走査対象に含まれてよい。
+ *
+ * ヘルパの扱い: `_`-prefix ヘルパは prototype から列挙して個別に走査する。`#`-private
+ * メソッドは prototype に現れないため、**クラスソース全体（親クラス連鎖含む）も走査する**。
+ * record 中に実行され得るコードはすべて対象であり、未到達のヘルパも fail-closed で
+ * 拒否される（到達可能性はソースからは判定できない）。
+ *
+ * 検出できない残余はヘッダ docstring / semantic-contract-programming.md「残余リスク」を参照
+ * （クラス外の関数・eval / new Function・`for`/`while` のループ条件）。
+ */
+const NATIVE_CONTROL_TOKEN = /\?\?=|&&=|\|\|=|\?\?|\?\.|&&|\|\||===|!==|==|!=|\bif\s*\(|\bswitch\s*\(|[?!]/;
+/** 正規表現リテラルが直前トークンの直後に開始し得るか（`/` を除算と区別する軽量判定）。 */
+const REGEX_PRECEDING_KEYWORDS = /* @__PURE__ */ new Set([
+    "return", "typeof", "instanceof", "in", "of", "case", "do", "else", "void", "delete", "throw", "new", "yield", "await",
+]);
+const WORD_CHAR = /[A-Za-z0-9_$#]/;
+function regexCanFollow(prev, word) {
+    if (prev === "")
+        return true;
+    if (WORD_CHAR.test(prev))
+        return REGEX_PRECEDING_KEYWORDS.has(word);
+    return !")]}\"'`.".includes(prev);
+}
+/**
+ * ソースから「コードでないテキスト」を空白化する（インデックス保存 — エラー位置抜粋用）:
+ * 文字列リテラル内容 / テンプレートリテラルのテキスト部（`${...}` 内コードは保持）/
+ * 行・ブロックコメント / 正規表現リテラル本体。
+ */
+function stripNonCode(src) {
+    const out = src.split("");
+    const blank = (idx) => {
+        if (out[idx] !== "\n")
+            out[idx] = " ";
+    };
+    // モードスタック: code（`${...}` ネスト用に {}-depth を持つ）と template。
+    const stack = [{ tpl: false, braces: 0 }];
+    let prev = ""; // 直前の有意（非空白）コード文字
+    let word = ""; // 直前の識別子/キーワード（regex 開始判定用）
+    let prevWasWord = false;
+    let i = 0;
+    while (i < src.length) {
+        const top = stack[stack.length - 1];
+        const ch = src[i];
+        if (top.tpl) {
+            if (ch === "\\") {
+                blank(i);
+                if (i + 1 < src.length)
+                    blank(i + 1);
+                i += 2;
+                continue;
+            }
+            if (ch === "`") {
+                stack.pop();
+                i++;
+                prev = "`";
+                word = "";
+                prevWasWord = false;
+                continue;
+            }
+            if (ch === "$" && src[i + 1] === "{") {
+                stack.push({ tpl: false, braces: 0 });
+                i += 2;
+                prev = "{";
+                word = "";
+                prevWasWord = false;
+                continue;
+            }
+            blank(i);
+            i++;
+            continue;
+        }
+        const nx = src[i + 1];
+        if (ch === "/" && nx === "/") {
+            while (i < src.length && src[i] !== "\n")
+                blank(i++);
+            continue;
+        }
+        if (ch === "/" && nx === "*") {
+            blank(i);
+            blank(i + 1);
+            i += 2;
+            while (i < src.length && !(src[i] === "*" && src[i + 1] === "/"))
+                blank(i++);
+            if (i < src.length) {
+                blank(i);
+                blank(i + 1);
+                i += 2;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            i++;
+            while (i < src.length && src[i] !== ch && src[i] !== "\n") {
+                if (src[i] === "\\") {
+                    blank(i);
+                    i++;
+                    if (i < src.length) {
+                        blank(i);
+                        i++;
+                    }
+                    continue;
+                }
+                blank(i);
+                i++;
+            }
+            if (i < src.length && src[i] === ch)
+                i++;
+            prev = ch;
+            word = "";
+            prevWasWord = false;
+            continue;
+        }
+        if (ch === "`") {
+            stack.push({ tpl: true, braces: 0 });
+            i++;
+            prev = "`";
+            word = "";
+            prevWasWord = false;
+            continue;
+        }
+        if (ch === "/" && regexCanFollow(prev, word)) {
+            blank(i);
+            i++;
+            let inClass = false;
+            while (i < src.length && (inClass || src[i] !== "/") && src[i] !== "\n") {
+                if (src[i] === "\\") {
+                    blank(i);
+                    i++;
+                    if (i < src.length) {
+                        blank(i);
+                        i++;
+                    }
+                    continue;
+                }
+                if (src[i] === "[")
+                    inClass = true;
+                else if (src[i] === "]")
+                    inClass = false;
+                blank(i);
+                i++;
+            }
+            if (i < src.length && src[i] === "/") {
+                blank(i);
+                i++;
+            }
+            while (i < src.length && /[a-z]/i.test(src[i])) {
+                blank(i);
+                i++;
+            }
+            prev = "/";
+            word = "";
+            prevWasWord = false;
+            continue;
+        }
+        if (ch === "{")
+            top.braces++;
+        else if (ch === "}") {
+            if (top.braces === 0 && stack.length > 1) {
+                stack.pop();
+                i++;
+                prev = "}";
+                word = "";
+                prevWasWord = false;
+                continue;
+            }
+            top.braces--;
+        }
+        if (WORD_CHAR.test(ch)) {
+            word = prevWasWord ? word + ch : ch;
+            prevWasWord = true;
+        }
+        else {
+            prevWasWord = false;
+            if (!/\s/.test(ch))
+                word = "";
+        }
+        if (!/\s/.test(ch))
+            prev = ch;
+        i++;
+    }
+    return out.join("");
+}
+/** 検出トークン → 表示名と record-form の置き換え案内。 */
+function nativeControlHint(token) {
+    if (token.startsWith("if"))
+        return { name: "if (...)", hint: "use when(cond, () => then, () => else)" };
+    if (token.startsWith("switch"))
+        return { name: "switch (...)", hint: "use when(...) chains with eq(...) conditions" };
+    switch (token) {
+        case "??=":
+        case "&&=":
+        case "||=":
+            return { name: token, hint: "authoring is declarative; bind a fresh const via coalesce/and/or builders" };
+        case "??":
+            return { name: "??", hint: "use coalesce(a, b)" };
+        case "?.":
+            return { name: "?.", hint: "use opt(x).field (refOpt)" };
+        case "&&":
+            return { name: "&&", hint: "use when(cond, () => x) for a guard, or and(a, b) for a boolean" };
+        case "||":
+            return { name: "||", hint: "use or(a, b) for a boolean, or coalesce(a, b) for a default" };
+        case "===":
+        case "==":
+            return { name: token, hint: "use eq(a, b)" };
+        case "!==":
+        case "!=":
+            return { name: token, hint: "use ne(a, b)" };
+        case "?":
+            return { name: "?:", hint: "use when(cond, () => then, () => else)" };
+        default:
+            return { name: "!", hint: "use not(x) or ne(a, b)" };
+    }
+}
+/** method / helper / class ソースを走査し、ネイティブ制御構文を fail-closed で拒否する。 */
+function scanNativeControlSyntax(source, label) {
+    const stripped = stripNonCode(source);
+    const bodyStart = stripped.indexOf("{"); // 本体（最初の `{` 以降）のみ走査する
+    if (bodyStart < 0)
+        return;
+    const m = NATIVE_CONTROL_TOKEN.exec(stripped.slice(bodyStart + 1));
+    if (!m)
+        return;
+    const at = bodyStart + 1 + m.index;
+    const excerpt = source
+        .slice(Math.max(0, at - 30), Math.min(source.length, at + 30))
+        .replace(/\s+/g, " ")
+        .trim();
+    const { name, hint } = nativeControlHint(m[0]);
+    afail("NATIVE_CONTROL_SYNTAX", `${label}: native control syntax '${name}' cannot be observed over recorded values at build time (JS Proxy has no ToBoolean/equality trap) and would silently mislower the DAG — ${hint} (near \`${excerpt}\`)`);
+}
+/**
+ * compileBehaviors — `SemanticBehavior` 継承（または `@behavior` 付き）クラスを
+ * component-graph IR（scp-ir-architecture.md §5）へ lower する共有 Compiler。
+ *
+ * - **各 public メソッド = 1 root Behavior**（`components[]` の 1 エントリ。名前 = メソッド名）。
+ *   `#`-private はランタイム不可視でそもそも列挙されない。TS の `private` 修飾子は型消去で
+ *   ランタイムに残らないため、**評価ベースのヘルパ規約は `#` または `_`-prefix**（`_` 始まりは
+ *   publish されない）。ヘルパはメソッド本体からの呼び出しで record にインライン展開される。
+ * - 評価の**前に**メソッド / ヘルパ / クラスソースを {@link scanNativeControlSyntax} で走査し、
+ *   評価では観測できないネイティブ制御構文（`?:` / `&&` / `||` / `??` / `?.` / `!` /
+ *   `==`/`===`/`!=`/`!==` / `if` / `switch` / 複合論理代入）を `NATIVE_CONTROL_SYNTAX` で
+ *   fail-closed に拒否する（bc#24 audit fix — 残余はヘッダ docstring 参照）。
+ * - メソッド本体は throwing-sentinel recorder で 1 回評価され、`$` 参照・component 呼び出し・
+ *   structured control（{@link when} / `.map`）が body ノード・Wire・plan に lower される。
+ * - 生成 IR は `assertPortableComponentGraph` を必ず通してから返す（fail-closed の自己検査）。
+ *   実行は既存の `runBehavior` がそのまま担う。
+ *
+ * effect（Query/Command）はここでは一切扱わない — {@link classifyBehaviorEffect} を参照。
+ */
+export function compileBehaviors(cls, opts = {}) {
+    if (!isBehaviorClass(cls))
+        afail("NOT_A_BEHAVIOR_CLASS", `class '${cls?.name ?? String(cls)}' is not a behavior class (extend SemanticBehavior or mark it with @behavior)`);
+    const proto = cls.prototype;
+    const methodNames = Object.getOwnPropertyNames(proto).filter((name) => {
+        if (name === "constructor" || name.startsWith("_") || name.startsWith("#"))
+            return false;
+        const d = Object.getOwnPropertyDescriptor(proto, name);
+        return typeof d?.value === "function";
+    });
+    if (methodNames.length === 0)
+        afail("NO_PUBLIC_METHOD", `class '${cls.name}' declares no public method (each public method is one root Behavior)`);
+    // ── source scan（評価の前に fail loud — NATIVE_CONTROL_SYNTAX）─────────────────
+    // public メソッドと `_`-prefix ヘルパは個別に（正確なラベルで）、`#`-private ヘルパは
+    // prototype から列挙できないためクラスソース全体（親クラス連鎖含む）で走査する。
+    for (const method of methodNames)
+        scanNativeControlSyntax(proto[method].toString(), `method '${method}'`);
+    for (const name of Object.getOwnPropertyNames(proto)) {
+        if (name === "constructor" || methodNames.includes(name))
+            continue;
+        const d = Object.getOwnPropertyDescriptor(proto, name);
+        if (typeof d?.value === "function")
+            scanNativeControlSyntax(d.value.toString(), `helper '${name}'`);
+    }
+    for (let k = cls; typeof k === "function" && k !== SemanticBehavior && k !== Function.prototype; k = Object.getPrototypeOf(k)) {
+        const src = Function.prototype.toString.call(k);
+        if (!/\{\s*\[native code\]\s*\}/.test(src))
+            scanNativeControlSyntax(src, `class '${k.name || "<anonymous>"}'`);
+    }
+    const instance = new cls();
+    const components = [];
+    for (const method of methodNames) {
+        const frame = {
+            method,
+            nodes: [],
+            nodeIds: new Set(),
+            inputPorts: new Map(),
+            seq: 0,
+            mapSeq: 0,
+            branchStack: [],
+            pendingMap: null,
+        };
+        const dollar = makeExpr({ node: { ref: [] }, refPath: [], refOp: "ref", isInput: true });
+        currentFrame = frame;
+        let returned;
+        try {
+            returned = proto[method].call(instance, dollar);
+        }
+        finally {
+            currentFrame = null;
+        }
+        if (returned === undefined)
+            afail("BAD_OUTPUT", `method '${method}' must return its Output Port (got undefined)`);
+        if (returned instanceof Promise)
+            afail("BAD_OUTPUT", `method '${method}' must be synchronous and declarative (async/await is derived by the compiler, not written)`);
+        const output = lowerValue(returned, `method '${method}' output`);
+        const inputPorts = {};
+        for (const [k, s] of frame.inputPorts)
+            inputPorts[k] = opts.inputPorts?.[method]?.[k] ?? s;
+        // 上書き schema にしか現れない Port も契約として載せる（型抽出ツールの接続点）。
+        for (const [k, s] of Object.entries(opts.inputPorts?.[method] ?? {}))
+            if (!(k in inputPorts))
+                inputPorts[k] = s;
+        // lowering の末尾は builder.ts の共有 core（B-3）: Component 組み立て・plan 導出
+        //（Kahn levels）・決定的正規化（キーソート）・Guard 自己検査は recorder 経路と
+        // データ登録経路（buildComponentDefinition）の単一実装。catalog port 照合は
+        // record 時（recordComponentCall）に同じ共有関数で済ませているため catalog は渡さない。
+        components.push(buildComponentCore({ name: method, inputPorts, body: frame.nodes, output }, { concurrency: opts.concurrency ?? DEFAULT_PLAN_CONCURRENCY }));
+    }
+    const ir = { irVersion: 1, exprVersion: opts.exprVersion ?? SPEC_VERSIONS.expression, components };
+    assertPortableComponentGraph(ir); // fail-closed 自己検査（P0-2 Guard を必ず通す）
+    return ir;
+}
+// ── effect 導出（consumer の CQRS 層のための共有ヘルパ — authoring は effect 非依存）────
+/**
+ * referencedComponents — lowering 済み合成コンポーネントの body が参照する catalog 名
+ * （componentRef / map。重複除去・出現順）。
+ */
+export function referencedComponents(component) {
+    const out = [];
+    for (const n of component.body) {
+        const name = "map" in n ? n.map.component : "cond" in n ? null : n.component;
+        if (name !== null && !out.includes(name))
+            out.push(name);
+    }
+    return out;
+}
+/**
+ * classifyBehaviorEffect — CQRS の Query/Command 分類を **component graph から導出**する
+ * consumer 向けヘルパ。authoring は effect 非依存（Query/Command の語彙を持たない）であり、
+ * 分類は「body が consumer の write-catalog（`PutItem`/`Insert`/… — consumer が指定）を
+ * 参照するか」という graph の性質にすぎない、という責務分離（bc#24 / litedbmodel v2 §2.4）の
+ * 実装点。
+ */
+export function classifyBehaviorEffect(component, writeComponents) {
+    const writes = new Set(writeComponents);
+    return referencedComponents(component).some((c) => writes.has(c)) ? "writing" : "read-only";
+}
+//# sourceMappingURL=authoring.js.map