litedbmodel 2.0.0 → 2.0.2

package/dist/scp/codegen.d.ts

@@ -1,131 +1,189 @@
 /**
- * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11).
+ * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11; makeSQL flip,
+ * epic #43/#45 Phase B; #60 milestone 1 — typed-NATIVE READ codegen, bc#77/#90).
  *
- * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成
- * runtime≈0, 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It
- * takes a §8 {@link SqlBundle} (already Backend-Compiled TS-side, WS1↔WS3) and, per target
- * language, emits:
+ * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成 runtime≈0,
+ * 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It takes a §8 STATIC
+ * makeSQL {@link SqlBundle} and, per target language, emits:
  *
- *  1. **Behavior module** — bc's SHARED generator (`generateModule`, bc#13) run over the
- *     bundle's SURROGATE component wrapped as a portable {@link ComponentGraphIR}. The generator
- *     bakes that IR as a language-native LITERAL (no runtime JSON parse) and emits a `bind(handlers)`
- *     accessor that delegates to the EXISTING runtime-core `runBehavior`. litedbmodel writes NO
- *     execution logic here — codegen is upstream-owned (bc), we only SUPPLY the input.
- *  2. **SQL catalog companion** — a pure-JSON sidecar carrying the litedbmodel-specific bundle
- *     fields that are OUTSIDE bc's portable-IR vocabulary (`operations` / `dialect` /
- *     `optionalHeads` / `relations` / `transaction`). This is the "SQL catalog supplied to the
- *     shared generator" (§9): a codegen consumer's thin SQL-handler layer reads it to render →
- *     execute, exactly as the mode-2 thin-runtime handler does. It is byte-identical to the bundle
- *     minus the (now baked-as-literal) `component`/`irVersion`/`exprVersion`.
+ *  1. **Behavior module** — bc's SHARED generator run over the bundle's portable IR through bc's
+ *     de-interpreted, RUNTIME-FREE emitter. For a READ bundle covered by bc's typed-NATIVE
+ *     endpoint (`rust-typed-native` / `go-typed-native`, bc#77/#90 — the 1.0 read de-box: fully
+ *     concrete `HandlerNR<Comp>`/`InNR<Comp>`/`PortsNR<Comp><node>`/`RawRowNR<Comp><node>` structs,
+ *     ZERO boxed `Value`/`RawValue`, ZERO IR baked into the module), the CODEGEN-ONLY lowering
+ *     below ({@link lowerReadGraphForTypedNative}) makes the read's shape structurally ELIGIBLE
+ *     (splits the surrogate `__scope` boxed-obj port into individual scalar ref ports + types the
+ *     component's `inputPorts` from the schema) before handing it to bc. For a WRITE bundle, or a
+ *     READ shape typed-native does not (yet) cover, codegen uses bc's existing de-interpreted
+ *     STRAIGHT-LINE endpoint (`<lang>-straightline`, bc#75) — see {@link typedEmitterFor}.
+ *  2. **SQL catalog companion** — the pure-JSON STATIC makeSQL catalog (per-node statement
+ *     templates / relations / transaction). A codegen consumer's thin SQL layer reads it to
+ *     evaluate skip + value-specs → assemble → render → execute (identically to the mode-2 runtime).
  *
- * ## Why this is byte-identical to the thin-runtime (mode-2), by construction
+ * ## #60 milestone 1 scope (CODEGEN-PATH ONLY)
  *
- * The mode-2 thin-runtime ({@link executeBundle}) computes
- * `runBehavior({components:[bundle.component]}, buildHandlers(db, operations, dialect),
- * normalizeInput(...), name)`. The generated module bakes `IR === bundle.component` (proven by
- * the FNV-1a fingerprint the generator embeds and re-checks at load) and its `bind(handlers)`
- * calls the SAME `runBehavior(IR, handlers, input, name)`. So when a codegen runtime pairs the
- * generated `bind` with the SAME {@link buildHandlers} + {@link normalizeInput} (from the SQL
- * catalog companion), it drives the identical core over the identical IR and handlers — the SQL
- * text (all dialects) and the results are identical, NOT approximately equal. The TS leg PROVES
- * this by executing the generated module and asserting exact equality vs `executeBundle` AND vs
- * the frozen conformance vector (see `codegenExecuteBundleForTest`).
+ * This lowering exists SOLELY for the codegen emitter call — it builds a NEW, separate
+ * `ComponentGraphIR` from the bundle's `readGraph`; it never mutates `SqlBundle`/`ReadGraph` and
+ * never touches the shared `readGraph`/`executeReadGraph` the ir/interpret exec surface (and the
+ * frozen conformance corpus) depend on. Those keep consuming the ORIGINAL boxed-`__scope`-port
+ * surrogate IR ({@link bundleToPortableIR}), completely unaffected by anything in this file.
  *
- * ## Language support (bc#13 capability — the honest scope boundary)
+ * ## Behavior-identical to the thin-runtime (mode-2), by construction
  *
- * bc's shared generator registers emitters for FIVE languages
- * ({@link CODEGEN_LANGUAGES}); Go IS among them (bc#13 SP2 `emit-go.ts`). So litedbmodel mode-3
- * codegen covers all five — TS/Python/Go/Rust/PHP. If a future litedbmodel construct needed an
- * emitter bc does not provide, the honest move is to ESCALATE to bc (bc#22 pattern), never to
- * fork a parallel litedbmodel-local generator (that would defeat the "codegen は上流所有" design).
+ * The generated module is observationally equivalent to `runBehavior` (same values, same emitted
+ * op sequence, same Failure code/message), and the companion IS the bundle, so a codegen runtime
+ * that drives it follows the IDENTICAL static-makeSQL render/execute path {@link executeBundle}
+ * uses — SQL text (all dialects) and results are identical, not approximately equal. The TS leg
+ * PROVES this by executing via the artifact and asserting exact equality vs {@link executeBundle}
+ * (see {@link codegenExecuteBundleForTest}).
+ *
+ * ## No literal-bake / no boxed fallback
+ *
+ * typed-native fails CLOSED on an uncovered shape (a `map`/`cond` relation kind it does not cover,
+ * or an input head that cannot lower to a native scalar — e.g. an IN-list's array-typed head).
+ * Such a shape is NOT silently regenerated on the boxed `-typed`/`-typed-raw` emitter — it THROWS,
+ * naming the exact gap, so it can be tracked as a bc coverage gap (bc#86) rather than masked.
  */
 import { type ComponentGraphIR, type GeneratedModule, type Scope, type Value } from 'behavior-contracts';
 import type { SqlBundle, SqliteDb } from './runtime';
-import { type DialectName } from './dialect';
-import type { CompiledOperation } from './ir';
+import type { DialectName } from './dialect';
 import type { RelationOp } from './relation';
-import type { TransactionPlan } from './write-plan';
+import type { ReadGraph } from './makesql/static-bundle';
+import type { TransactionPlan } from './makesql/tx';
+import { type ColumnTypeResolver } from './coltype';
 /**
  * The languages litedbmodel mode-3 codegen supports — exactly the set bc's shared generator
- * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). This is a FIXED capability the
- * generator advertises via `registeredLanguages()`; {@link assertLanguageSupported} verifies the
- * requested language against the LIVE registry so a bc capability change is caught loudly rather
- * than silently drifting from this constant.
+ * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). {@link codegenEmitterFor}
+ * verifies against the LIVE registry so a bc capability drift is caught loudly.
  */
 export declare const CODEGEN_LANGUAGES: readonly ["typescript", "python", "go", "rust", "php"];
 export type CodegenLanguage = (typeof CODEGEN_LANGUAGES)[number];
 /**
- * The SQL catalog companion (spec §9 — the "SQL catalog supplied to the shared generator"): the
- * litedbmodel-specific §8 bundle fields that live OUTSIDE bc's portable-IR vocabulary and so are
- * NOT baked into the generated behavior module. A codegen consumer's thin SQL-handler layer reads
- * this sidecar to render → bind → execute (identically to the mode-2 handler). Pure JSON —
- * round-trips losslessly (proven by the codegen conformance leg).
+ * The bc READ emitter litedbmodel drives for each codegen target (#60 milestone 1): the
+ * **de-interpreted, RUNTIME-FREE typed-NATIVE** endpoint (bc#77/#90) for go/rust — ZERO boxed
+ * `Value`/`RawValue`, ZERO IR baked into the module, concrete `HandlerNR`/`InNR`/`PortsNR`/
+ * `RawRowNR` structs. There is **NO literal / straight-line / boxed-typed fallback** for a read: an
+ * unspec'd fallback is INVALID (it silently swallows the "this shape can't be natively codegen'd"
+ * signal) — a read shape typed-native does not cover MUST fail loudly at generation, naming the gap
+ * (report it as a bc#86 coverage gap), never silently regenerate on `-typed`/`-typed-raw`.
+ *
+ * `-typed-raw` (bc#76, the boxed-wire intermediate) and `-typed` (the boxed-Value intermediate) are
+ * RETIRED from litedbmodel's codegen surface entirely (#60 milestone 1) — typed-native supersedes
+ * both for every read shape it covers (bc#77/#90: single-componentRef reads AND the `map`
+ * relationKind:single|connection shape, bc#86 part 2).
+ *
+ * - ts: **no typed-native endpoint registered yet** (bc has not shipped `typescript-typed-native`).
+ *   TS stays on its existing `typescript-typed` (boxed) endpoint until bc adds one — a DECLARED,
+ *   reported gap (not silently mirrored to go/rust's retirement), tracked as a bc#77 TS follow-up.
+ * - **python/php: NOT present.** bc registers no de-boxed typed endpoint for them (capability limit).
+ *   litedbmodel does NOT substitute the literal (≈ir) emitter — that would be an unspec'd fallback.
+ *   Codegen for py/php is a bc capability gap that ERRORS (ESCALATE to bc), never a silent literal.
+ *
+ * WRITES (batchInsert / gate-first tx) are NOT reads — they are NOT routed through this table at
+ * all (#60 milestone 1): a write bundle stays on the existing write/tx execution path
+ * (`executeTransactionBundle` / the native adapter's hand-written tx mirror), never a codegen
+ * module, boxed or typed-raw. {@link generateCodegenArtifact} throws if asked to codegen a write.
+ */
+export declare const CODEGEN_EMITTER: Partial<Record<CodegenLanguage, string>>;
+/**
+ * The SQL catalog companion (spec §9): the STATIC makeSQL bundle fields the codegen consumer's
+ * thin SQL layer reads to evaluate + render + execute. Pure JSON — round-trips losslessly.
  */
 export interface SqlCatalogCompanion {
-    /** Backend-Compiled SQL IR per catalog node id (§8) — `sql` + fragment tree + closed-set params. */
-    readonly operations: Record<string, CompiledOperation>;
     /** Target SQL dialect (`sqlite`/`postgres`/`mysql`) — compiled once, TS-side (spec §10). */
     readonly dialect: DialectName;
+    /** READ bundles: the portable read graph (surrogate IR + per-node makeSQL statements). */
+    readonly readGraph?: ReadGraph;
+    /** WRITE bundles: the single base-write makeSQL statement template. */
+    readonly statement?: {
+        readonly sql: string;
+        readonly params: readonly unknown[];
+        readonly skip?: unknown;
+    };
     /** Input heads normalized to present-as-null (absent-key SKIP) — mirrors the bundle. */
     readonly optionalHeads: readonly string[];
-    /** Pre-compiled read-relation batch ops (spec §5/§8), keyed by relation name. */
+    /** Pre-compiled STATIC read-relation batch ops (spec §5/§8), keyed by relation name. */
     readonly relations: Record<string, RelationOp>;
     /** Derived gate-first write-time-relations transaction plan (spec §6/§8), for a Command bundle. */
     readonly transaction?: TransactionPlan;
+    /**
+     * WRITE bundles: the codegen typed-de-box `outputType` (the TransactionResult typed shape). Rides
+     * the companion so a codegen consumer that reassembles the bundle from the artifact round-trips it
+     * losslessly (the read de-box carries its outType/outputType inside `readGraph.ir` instead).
+     */
+    readonly outputType?: unknown;
 }
 /** The full codegen artifact for one bundle × one language. */
 export interface CodegenArtifact {
     /** The target language. */
     readonly language: CodegenLanguage;
-    /** The generated behavior module (bc's shared generator output — IR baked as a native literal). */
+    /** The generated behavior module (bc's SHARED STRAIGHT-LINE generator output — real static code). */
     readonly module: GeneratedModule;
-    /** The SQL catalog companion sidecar (the litedbmodel-specific execution catalog). */
+    /** The SQL catalog companion sidecar (the STATIC makeSQL execution catalog). */
     readonly companion: SqlCatalogCompanion;
-    /**
-     * The portable IR that WAS baked into {@link module} (the surrogate component + envelope). Kept
-     * on the artifact so the in-process TS equivalence check drives the IDENTICAL IR the emitted
-     * source embeds — the generator's fingerprint (checked at the emitted module's load) proves the
-     * baked literal equals this object.
-     */
-    readonly ir: ComponentGraphIR;
+    /** The originating bundle (so the equivalence leg re-executes the SAME static bundle). */
+    readonly bundle: SqlBundle;
 }
 /**
- * The portable {@link ComponentGraphIR} view of a §8 bundle: the surrogate component (wiring /
- * plan / output / `__scope` ports only — every SQL-structural port already collapsed to portable
- * Expression IR TS-side) wrapped with the bundle's IR envelope. This is EXACTLY the IR
- * {@link executeBundle} feeds `runBehavior`, so baking it is what makes codegen equivalent.
+ * The portable {@link ComponentGraphIR} view of a §8 bundle: a read bundle's surrogate IR (each
+ * SQL node → a `makeSQL` node), or the single `makeSQL` component IR for a write. This is the
+ * ORIGINAL boxed-`__scope`-port form the ir/interpret exec surface's `executeReadGraph` also
+ * consumes (via `bundle.readGraph.ir` directly) — {@link generateCodegenArtifact} does NOT use
+ * this for a READ bundle (it uses the codegen-only lowered form, {@link lowerReadGraphForTypedNative});
+ * this function is kept for callers that want the untouched portable IR (e.g. diagnostics, the
+ * write path, or a future straight-line fallback caller).
  */
 export declare function bundleToPortableIR(bundle: SqlBundle): ComponentGraphIR;
+/** A head could not be typed for typed-native codegen — the read is NOT typed-native-coverable. */
+export declare class TypedNativeCoverageError extends Error {
+    readonly component: string;
+    readonly reasons: readonly string[];
+    constructor(component: string, reasons: readonly string[]);
+}
 /**
- * Assert the requested language is one bc's shared generator can actually emit — checked against
- * the LIVE generator registry, not just the {@link CODEGEN_LANGUAGES} constant, so a bc capability
- * drift (an emitter removed/renamed upstream) fails LOUDLY here instead of surfacing as a broken
- * generated module. `generateModule` itself also fail-closes on an unknown language; this is the
- * earlier, litedbmodel-scoped guard with the honest "bc supports X" message.
+ * Lower a read bundle's surrogate `ComponentGraphIR` into a NEW, CODEGEN-ONLY IR eligible for bc's
+ * typed-native endpoint (#60 milestone 1): split the single `__scope: {obj:{...}}` boxed port into
+ * individual scalar `{ref:[head]}` ports, and type the component's `inputPorts` from the schema
+ * (via {@link deriveHeadTypesFromStatements}). Throws {@link TypedNativeCoverageError} if any
+ * referenced head cannot be natively typed (e.g. an IN-list's array head) — NO silent `unknown`
+ * port, NO fallback. Does NOT mutate `bundle`/`bundle.readGraph` (a fresh IR object is returned);
+ * the ir/interpret exec surface's `executeReadGraph` keeps consuming the ORIGINAL `readGraph.ir`.
+ *
+ * Scope: bc's typed-native predicate itself still governs `map`/`cond`/relationKind/policy
+ * coverage (this lowering does not special-case those — `generateModule` fails closed on them with
+ * its own detailed diagnostic, which this function does not need to duplicate).
  */
-export declare function assertLanguageSupported(language: string, registered: readonly string[]): asserts language is CodegenLanguage;
+export declare function lowerReadGraphForTypedNative(readGraph: ReadGraph, resolveColumnType: ColumnTypeResolver): ComponentGraphIR;
 /**
- * Generate the mode-3 codegen artifact for ONE §8 bundle in ONE target language: bc's SHARED
- * generator bakes the surrogate IR literal + emits `bind(handlers)`, and we attach the SQL catalog
- * companion. litedbmodel supplies the input (IR + catalog); bc owns the emitter.
- *
- * @param registeredLanguages the live `registeredLanguages()` from bc (injected so the guard sees
- *   the actual generator capability; the caller passes `bc.registeredLanguages()`).
- * @param runtimeImport optional runtime-core import specifier override (test/vendored layouts);
- *   forwarded verbatim to the generator so the generated code stays deterministic.
+ * Resolve the READ codegen emitter for a target language, or throw. No fallback: a language
+ * without a registered endpoint is a bc capability gap that fails LOUDLY (never a silent
+ * substitution of the literal/interpreter/boxed emitter — an unspec'd fallback is invalid).
  */
-export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], runtimeImport?: string): CodegenArtifact;
+export declare function typedEmitterFor(language: string, registered: readonly string[]): string;
 /**
- * The TS codegen EXECUTION path used to PROVE byte-identity: reconstruct the exact call the
- * generated TS module's `bind(handlers)` makes — `runBehavior(IR, handlers, normalizedInput,
- * name)` — where `IR` is the baked portable IR and `handlers` are the SAME SQL handlers the SQL
- * catalog companion drives ({@link buildHandlers}). Executing this and comparing to
- * {@link executeBundle} is a REAL byte-identity check on the codegen path (the generated TS module
- * is separately IMPORTED and run in the conformance leg to prove the emitted source itself agrees).
+ * Shape-INDEPENDENT emitter resolution — identical to {@link typedEmitterFor} now that there is
+ * exactly one READ endpoint per language (kept as a distinct export for callers that historically
+ * used the shape-independent form; both resolve the SAME table).
+ */
+export declare function codegenEmitterFor(language: string, registered: readonly string[]): string;
+/**
+ * Generate the mode-3 READ codegen artifact for ONE §8 READ bundle in ONE target language. For a
+ * typed-NATIVE target (go/rust, bc#77/#90), lowers the bundle's surrogate read graph into the
+ * typed-native-eligible IR ({@link lowerReadGraphForTypedNative}) first — REAL static native
+ * source, RUNTIME-FREE, no baked-IR interpret path. For any OTHER registered endpoint (currently
+ * only TS's boxed `typescript-typed`, which has no typed-native counterpart yet), the ORIGINAL
+ * portable IR ({@link bundleToPortableIR}) is used unchanged — the lowering is typed-native-only
+ * and would needlessly narrow a boxed endpoint's existing coverage. litedbmodel supplies the
+ * input (portable IR + catalog); bc owns the emitter.
  *
- * This mirrors {@link executeBundle} field-for-field, but drives the components/handlers via the
- * codegen ARTIFACT (baked IR + companion) rather than the raw bundle — so a divergence between the
- * codegen artifact and the bundle would surface as a mismatch.
+ * WRITE bundles are OUT OF SCOPE (#60 milestone 1: writes stay on the existing write/tx execution
+ * path, never a codegen module) — throws if `bundle.readGraph` is absent.
+ */
+export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], resolveColumnType: ColumnTypeResolver, runtimeImport?: string): CodegenArtifact;
+/**
+ * The TS codegen EXECUTION path used to PROVE behavior-identity: a codegen runtime reads the SQL
+ * catalog companion (the STATIC makeSQL bundle) and evaluates skip + value-specs → assemble →
+ * render → execute — which is EXACTLY {@link executeBundle} over the SAME bundle.
  */
 export declare function codegenExecuteBundleForTest(artifact: CodegenArtifact, input: Scope, db: SqliteDb): Value;
 //# sourceMappingURL=codegen.d.ts.map

package/dist/scp/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/scp/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAkB,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACzH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAGrD,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,wDAAyD,CAAC;AACxF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,oGAAoG;IACpG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACvD,4FAA4F;IAC5F,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,wFAAwF;IACxF,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC/C,mGAAmG;IACnG,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;CACxC;AAED,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,sFAAsF;IACtF,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,gBAAgB,CAMtE;AAaD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAa5H;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,SAAS,MAAM,EAAE,EACtC,aAAa,CAAC,EAAE,MAAM,GACrB,eAAe,CAKjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,GAAG,KAAK,CAOxG"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/scp/codegen.ts"],"names":[],"mappings":"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"}