@world-engines/tmw 0.1.0-alpha.0

package/dist/compile-target-profile.js

@@ -0,0 +1,70 @@
+import { canonicalTmwBytes, tmwSha256Hex } from "./runtime-contract.js";
+export const COMPILE_TARGET_PROFILE_SCHEMA_VERSION = 1;
+const IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/u;
+function compareAscii(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function requireIdentifier(value, code) {
+    if (typeof value !== "string"
+        || !IDENTIFIER_PATTERN.test(value)
+        || value !== value.normalize("NFC"))
+        throw new Error(code);
+    return value;
+}
+function plainObject(value, code) {
+    if (typeof value !== "object"
+        || value === null
+        || Array.isArray(value)
+        || Object.getPrototypeOf(value) !== Object.prototype)
+        throw new Error(code);
+    return value;
+}
+function exactKeys(value, expected, code) {
+    const actual = Object.keys(value).sort();
+    const canonical = [...expected].sort();
+    if (actual.length !== canonical.length
+        || actual.some((key, index) => key !== canonical[index]))
+        throw new Error(code);
+}
+export function parseCompileTargetProfile(value) {
+    const profile = plainObject(value, "compile_target_profile_object_required");
+    exactKeys(profile, [
+        "schema_version",
+        "compiler_release",
+        "runtime_semantics",
+        "sdk_schema",
+        "artifact_format",
+        "stage_versions",
+    ], "compile_target_profile_fields_mismatch");
+    if (profile.schema_version !== COMPILE_TARGET_PROFILE_SCHEMA_VERSION) {
+        throw new Error("compile_target_profile_schema_version_invalid");
+    }
+    if (!Array.isArray(profile.stage_versions) || profile.stage_versions.length === 0) {
+        throw new Error("compile_target_profile_stage_versions_required");
+    }
+    const stageVersions = profile.stage_versions.map((value, index) => {
+        const stage = plainObject(value, `compile_target_stage_version_object_required:${index}`);
+        exactKeys(stage, ["stage_id", "stage_version"], `compile_target_stage_version_fields_mismatch:${index}`);
+        return Object.freeze({
+            stage_id: requireIdentifier(stage.stage_id, `compile_target_stage_id_invalid:${index}`),
+            stage_version: requireIdentifier(stage.stage_version, `compile_target_stage_version_invalid:${index}`),
+        });
+    }).sort((left, right) => compareAscii(left.stage_id, right.stage_id));
+    if (new Set(stageVersions.map((stage) => stage.stage_id)).size !== stageVersions.length) {
+        throw new Error("compile_target_stage_id_duplicate");
+    }
+    return Object.freeze({
+        schema_version: COMPILE_TARGET_PROFILE_SCHEMA_VERSION,
+        compiler_release: requireIdentifier(profile.compiler_release, "compile_target_compiler_release_invalid"),
+        runtime_semantics: requireIdentifier(profile.runtime_semantics, "compile_target_runtime_semantics_invalid"),
+        sdk_schema: requireIdentifier(profile.sdk_schema, "compile_target_sdk_schema_invalid"),
+        artifact_format: requireIdentifier(profile.artifact_format, "compile_target_artifact_format_invalid"),
+        stage_versions: Object.freeze(stageVersions),
+    });
+}
+export function canonicalCompileTargetProfileBytes(profile) {
+    return canonicalTmwBytes(parseCompileTargetProfile(profile));
+}
+export async function compileTargetProfileDigest(profile) {
+    return tmwSha256Hex(canonicalCompileTargetProfileBytes(profile));
+}

package/dist/compiled-plan.d.ts

@@ -0,0 +1,44 @@
+import type { TMW_RUNTIME_GENERATION } from "./runtime-contract.js";
+import type { TmwDiagnostic } from "./diagnostics.js";
+import type { TmwJsonValue } from "./runtime-contract.js";
+import type { EffectExecutionPolicy, EffectRewritePolicy } from "./effect-flow.js";
+import type { TriggerEdgeV3, TriggerNodeKindV3 } from "./trigger-document-v3.js";
+import type { TmwEffectiveTime } from "./time-domains.js";
+interface CompiledPlanNodeV3Base {
+    readonly stable_id: string;
+    readonly kind: TriggerNodeKindV3;
+    readonly effective_time: TmwEffectiveTime;
+    readonly dependencies: readonly string[];
+    readonly canonical_payload: TmwJsonValue;
+}
+export type CompiledPlanNodeV3 = (CompiledPlanNodeV3Base & {
+    readonly kind: "effect";
+    readonly execution_policy: EffectExecutionPolicy;
+    readonly rewrite_policy: EffectRewritePolicy;
+    readonly priority: number;
+    readonly idempotency_key: string;
+}) | (CompiledPlanNodeV3Base & {
+    readonly kind: Exclude<TriggerNodeKindV3, "effect">;
+});
+export interface CompiledPlanV3Core {
+    readonly plan_version: 3;
+    readonly runtime_generation: typeof TMW_RUNTIME_GENERATION;
+    readonly runtime_contract_hash: string;
+    readonly registry_version: string;
+    readonly document_sha256: string;
+    readonly nodes: readonly CompiledPlanNodeV3[];
+    readonly edges: readonly TriggerEdgeV3[];
+    readonly value_graph?: import("./value-graph.js").TmwValueGraphV1;
+}
+export interface CompiledPlanV3 extends CompiledPlanV3Core {
+    readonly plan_sha256: string;
+}
+export type CompileTmw3Result = {
+    readonly ok: true;
+    readonly plan: CompiledPlanV3;
+    readonly diagnostics: readonly TmwDiagnostic[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly TmwDiagnostic[];
+};
+export {};

package/dist/compiled-plan.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler-compatibility-gate.d.ts

@@ -0,0 +1,96 @@
+import { type CompileTargetProfile } from "./compile-target-profile.js";
+import type { CompilerStageCache } from "./compiler-stage-cache.js";
+import type { CompilerStageRegistry } from "./compiler-stage-registry.js";
+import { type NeutralSourceCompilerReceipt } from "./neutral-source-compiler.js";
+export declare const ACCEPTED_NEUTRAL_SOURCE_CORPUS_SCHEMA_VERSION: 1;
+export interface AcceptedNeutralSourceSectionDigest {
+    readonly section_key: string;
+    readonly sha256: string;
+    readonly byte_length: string;
+}
+export interface AcceptedNeutralSourceByteRangeWitness {
+    readonly kind: string;
+    readonly path: string;
+    readonly start: string;
+    readonly end: string;
+    readonly sha256: string;
+}
+export interface AcceptedNeutralSourceContentWitness {
+    readonly kind: string;
+    readonly section_key: string;
+    readonly sha256: string;
+    readonly metrics: Readonly<Record<string, string>>;
+}
+export interface AcceptedNeutralSourcePreservedSectionDigest {
+    readonly section_key: string;
+    readonly sha256: string;
+}
+export interface AcceptedNeutralSourceSizeWitness {
+    readonly kind: string;
+    readonly limit_bytes: string;
+    readonly source_byte_length: string;
+    readonly plus_one_byte_length: string;
+}
+export interface AcceptedNeutralSourceMutationWitness {
+    readonly after_head_sha256: string;
+    readonly after_manifest_sha256: string;
+    readonly after_revision: string;
+    readonly after_source_sha256: string;
+    readonly after_value_sha256: string;
+    readonly author_client: string;
+    readonly before_head_sha256: string;
+    readonly before_manifest_sha256: string;
+    readonly before_revision: string;
+    readonly before_source_base64: string;
+    readonly before_source_sha256: string;
+    readonly before_value_sha256: string;
+    readonly changed_field_path: string;
+    readonly changed_section_key: string;
+    readonly operation_id: string;
+    readonly preserved_section_digests: readonly AcceptedNeutralSourcePreservedSectionDigest[];
+    readonly preserved_unknown_sha256s: readonly string[];
+}
+export interface AcceptedNeutralSourceCorpusEntry {
+    readonly fixture_id: string;
+    readonly relative_path: string;
+    readonly source_sha256: string;
+    readonly scenario_id: string;
+    readonly manifest_sha256: string;
+    readonly acceptance_ref: string;
+    readonly section_digests: readonly AcceptedNeutralSourceSectionDigest[];
+    readonly target_profiles: readonly CompileTargetProfile[];
+    readonly byte_range_witnesses: readonly AcceptedNeutralSourceByteRangeWitness[];
+    readonly content_witnesses: readonly AcceptedNeutralSourceContentWitness[];
+    readonly mutation_witnesses: readonly AcceptedNeutralSourceMutationWitness[];
+    readonly size_witnesses: readonly AcceptedNeutralSourceSizeWitness[];
+}
+export interface AcceptedNeutralSourceCorpus {
+    readonly schema_version: typeof ACCEPTED_NEUTRAL_SOURCE_CORPUS_SCHEMA_VERSION;
+    readonly sources: readonly AcceptedNeutralSourceCorpusEntry[];
+}
+export interface CompilerCompatibilityCandidate {
+    readonly target_profile: CompileTargetProfile;
+    readonly registry: CompilerStageRegistry;
+    createCache(): CompilerStageCache;
+}
+export interface CompilerCompatibilityFixturePass {
+    readonly fixture_id: string;
+    readonly source_sha256: string;
+    readonly manifest_sha256: string;
+    readonly receipt: NeutralSourceCompilerReceipt;
+}
+export interface CompilerCompatibilityFixtureFailure {
+    readonly fixture_id: string;
+    readonly code: string;
+}
+export type CompilerCompatibilityGateResult = {
+    readonly promotable: true;
+    readonly passes: readonly CompilerCompatibilityFixturePass[];
+    readonly failures: readonly never[];
+} | {
+    readonly promotable: false;
+    readonly passes: readonly CompilerCompatibilityFixturePass[];
+    readonly failures: readonly CompilerCompatibilityFixtureFailure[];
+};
+export declare function parseAcceptedNeutralSourceCorpus(value: unknown): AcceptedNeutralSourceCorpus;
+export declare function evaluateCompilerCandidate(candidate: CompilerCompatibilityCandidate, corpusValue: unknown, loadFixture: (relativePath: string) => Promise<Uint8Array>): Promise<CompilerCompatibilityGateResult>;