@sazume/core 0.0.0-stage → 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 W3BGHOST
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# @sazume/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Economic reliability primitives for programmable-money applications.
+
+`@sazume/core` provides `EconomicIntent`, the `EconomicAdapter` boundary, reusable invariants, deterministic scenarios, the runner, and structured outcomes. The package evaluates observed application state; an adapter does not choose its own verdict.
+
+## Install
+
+```sh
+npm install @sazume/core@next
+```
+
+## Define an economic intent
+
+```ts
+import {
+  defineIntent,
+  settlementUniqueness,
+  recipientAmount,
+  fulfillmentUniqueness,
+  completionConsistency,
+} from "@sazume/core";
+
+const intent = defineIntent({
+  id: "ORDER-42",
+  payment: {
+    payer: "customer",
+    recipient: "merchant",
+    asset: { symbol: "USDC", decimals: 6 },
+    amount: 10_000n,
+  },
+  invariants: [
+    settlementUniqueness(),
+    recipientAmount(),
+    fulfillmentUniqueness(),
+    completionConsistency(),
+  ],
+});
+```
+
+Implement `EconomicAdapter` for the application state you need Sazume to observe, then pass it and scenarios to `sazume.run`. Amounts use integer base units (`bigint`); never use floating point for monetary values.
+
+See the [integration guide](https://sazume.vercel.app/docs/integration) for a complete adapter example.
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/dist/cjs/adapter.d.ts

@@ -0,0 +1,9 @@
+import type { EconomicIntent } from "./intent.js";
+import type { EconomicOutcome, FulfillmentResult, SettlementResult } from "./outcome.js";
+export interface EconomicAdapter {
+    settle(intent: EconomicIntent): Promise<SettlementResult>;
+    fulfill(intent: EconomicIntent): Promise<FulfillmentResult>;
+    markComplete(intent: EconomicIntent): Promise<void>;
+    observe(intent: EconomicIntent): Promise<EconomicOutcome>;
+    reset(): Promise<void>;
+}

package/dist/cjs/adapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./adapter.js";
+export * from "./intent.js";
+export * from "./invariant.js";
+export * from "./outcome.js";
+export * from "./reporter.js";
+export * from "./runner.js";
+export * from "./scenario.js";
+export * from "./trace.js";

package/dist/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter.js"), exports);
+__exportStar(require("./intent.js"), exports);
+__exportStar(require("./invariant.js"), exports);
+__exportStar(require("./outcome.js"), exports);
+__exportStar(require("./reporter.js"), exports);
+__exportStar(require("./runner.js"), exports);
+__exportStar(require("./scenario.js"), exports);
+__exportStar(require("./trace.js"), exports);

package/dist/cjs/intent.d.ts

@@ -0,0 +1,18 @@
+import type { EconomicInvariant } from "./invariant.js";
+export interface EconomicIntent {
+    id: string;
+    intentId: string;
+    payment: {
+        payer: string;
+        recipient: string;
+        asset: {
+            symbol: "USDC";
+            decimals: 6;
+        };
+        amount: bigint;
+    };
+    invariants: EconomicInvariant[];
+}
+type IntentInput = Omit<EconomicIntent, "intentId">;
+export declare function defineIntent(input: IntentInput): EconomicIntent;
+export {};

package/dist/cjs/intent.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineIntent = defineIntent;
+const node_crypto_1 = require("node:crypto");
+function defineIntent(input) {
+    if (input.payment.amount <= 0n)
+        throw new Error("Intent amount must be positive");
+    if (!input.id.trim())
+        throw new Error("Intent ID must not be empty");
+    const intentId = (0, node_crypto_1.createHash)("sha256").update(`sazume:intent:v1:${input.id}`).digest("hex");
+    return { ...input, intentId };
+}

package/dist/cjs/invariant.d.ts

@@ -0,0 +1,17 @@
+import type { EconomicIntent } from "./intent.js";
+import type { EconomicOutcome } from "./outcome.js";
+export interface InvariantResult {
+    name: string;
+    passed: boolean;
+    expected: string;
+    observed: string;
+    message?: string;
+}
+export interface EconomicInvariant {
+    name: string;
+    evaluate(intent: EconomicIntent, outcome: EconomicOutcome): InvariantResult;
+}
+export declare const settlementUniqueness: () => EconomicInvariant;
+export declare const recipientAmount: () => EconomicInvariant;
+export declare const fulfillmentUniqueness: () => EconomicInvariant;
+export declare const completionConsistency: () => EconomicInvariant;

package/dist/cjs/invariant.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionConsistency = exports.fulfillmentUniqueness = exports.recipientAmount = exports.settlementUniqueness = void 0;
+function invariant(name, evaluate) {
+    return { name, evaluate: (intent, outcome) => ({ name, ...evaluate(intent, outcome) }) };
+}
+const settlementUniqueness = () => invariant("Settlement uniqueness", (_intent, outcome) => ({
+    passed: outcome.settlement.count <= 1,
+    expected: "<= 1",
+    observed: String(outcome.settlement.count),
+    message: outcome.settlement.count > 1 ? "One economic intent produced multiple settlements." : undefined,
+}));
+exports.settlementUniqueness = settlementUniqueness;
+const recipientAmount = () => invariant("Recipient amount", (intent, outcome) => {
+    const applicable = outcome.completed;
+    const passed = !applicable || outcome.settlement.totalAmount === intent.payment.amount;
+    return {
+        passed,
+        expected: `${(intent.payment.amount / 1000000n).toString()}.${(intent.payment.amount % 1000000n).toString().padStart(6, "0")} USDC`,
+        observed: `${outcome.settlement.totalAmount} base units`,
+        message: applicable && !passed ? "Completed intent did not deliver exactly the intended amount." : undefined,
+    };
+});
+exports.recipientAmount = recipientAmount;
+const fulfillmentUniqueness = () => invariant("Fulfillment uniqueness", (_intent, outcome) => ({
+    passed: outcome.fulfillment.count <= 1,
+    expected: "<= 1",
+    observed: String(outcome.fulfillment.count),
+    message: outcome.fulfillment.count > 1 ? "One economic intent produced multiple fulfillments." : undefined,
+}));
+exports.fulfillmentUniqueness = fulfillmentUniqueness;
+const completionConsistency = () => invariant("Completion consistency", (_intent, outcome) => {
+    const passed = !outcome.completed || (outcome.settlement.count > 0 && outcome.fulfillment.count > 0);
+    return {
+        passed,
+        expected: "completed implies settlement and fulfillment",
+        observed: `completed=${outcome.completed}, settlements=${outcome.settlement.count}, fulfillments=${outcome.fulfillment.count}`,
+        message: !passed ? "Workflow claimed completion without settlement and fulfillment." : undefined,
+    };
+});
+exports.completionConsistency = completionConsistency;

package/dist/cjs/outcome.d.ts

@@ -0,0 +1,18 @@
+export interface EconomicOutcome {
+    intentId: string;
+    settlement: {
+        count: number;
+        totalAmount: bigint;
+    };
+    fulfillment: {
+        count: number;
+    };
+    completed: boolean;
+}
+export interface SettlementResult {
+    accepted: boolean;
+    amount: bigint;
+}
+export interface FulfillmentResult {
+    accepted: boolean;
+}

package/dist/cjs/outcome.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/reporter.d.ts

@@ -0,0 +1,2 @@
+import type { SazumeRunResult } from "./runner.js";
+export declare function report(result: SazumeRunResult, label: string): string;

package/dist/cjs/reporter.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.report = report;
+function formatAmount(amount) {
+    const whole = amount / 1000000n;
+    const fraction = (amount % 1000000n).toString().padStart(6, "0");
+    return `${whole}.${fraction} USDC`;
+}
+function report(result, label) {
+    const lines = ["SAZUME", `Economic Reliability Test — ${label}`, "────────────────────────────────", ""];
+    if (label.toUpperCase() === "UNSAFE") {
+        lines.push(`Intent        ${result.intent.id}`, `Expected      ${formatAmount(result.intent.payment.amount)}`, "");
+    }
+    for (const scenario of result.scenarios) {
+        lines.push(`${scenario.passed ? "✓" : "✕"} ${scenario.scenario}`);
+        if (!scenario.passed) {
+            lines.push("", "ECONOMIC INVARIANT VIOLATION");
+            for (const item of scenario.invariants.filter((invariant) => !invariant.passed)) {
+                lines.push("", item.name, `  expected    ${item.expected}`, `  observed    ${item.name === "Recipient amount" ? formatAmount(scenario.outcome.settlement.totalAmount) : item.observed}`);
+            }
+            lines.push("", "TRACE");
+            for (const entry of scenario.trace)
+                lines.push(`  ${String(entry.sequence).padStart(2, "0")} ${entry.type}`);
+        }
+    }
+    const passed = result.scenarios.filter((scenario) => scenario.passed).length;
+    const failed = result.scenarios.length - passed;
+    lines.push("", "────────────────────────────────", `${passed} passed`, `${failed} failed`, "", result.passed ? "ECONOMIC INTENT PRESERVED" : "ECONOMIC INTENT NOT PRESERVED");
+    return lines.join("\n");
+}

package/dist/cjs/runner.d.ts

@@ -0,0 +1,25 @@
+import type { EconomicAdapter } from "./adapter.js";
+import type { EconomicIntent } from "./intent.js";
+import type { InvariantResult } from "./invariant.js";
+import type { EconomicOutcome } from "./outcome.js";
+import type { Scenario } from "./scenario.js";
+import { type TraceEntry } from "./trace.js";
+export interface ScenarioResult {
+    scenario: string;
+    outcome: EconomicOutcome;
+    invariants: InvariantResult[];
+    trace: TraceEntry[];
+    passed: boolean;
+}
+export interface SazumeRunResult {
+    intent: EconomicIntent;
+    scenarios: ScenarioResult[];
+    passed: boolean;
+}
+export declare const sazume: {
+    run(input: {
+        intent: EconomicIntent;
+        adapter: EconomicAdapter;
+        scenarios: Scenario[];
+    }): Promise<SazumeRunResult>;
+};

package/dist/cjs/runner.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sazume = void 0;
+const trace_js_1 = require("./trace.js");
+exports.sazume = {
+    async run(input) {
+        const scenarios = [];
+        for (const scenario of input.scenarios) {
+            await input.adapter.reset();
+            const trace = new trace_js_1.ScenarioTrace();
+            await scenario.run({ intent: input.intent, adapter: input.adapter, trace });
+            const outcome = await input.adapter.observe(input.intent);
+            const invariants = input.intent.invariants.map((item) => item.evaluate(input.intent, outcome));
+            scenarios.push({ scenario: scenario.name, outcome, invariants, trace: trace.entries, passed: invariants.every((item) => item.passed) });
+        }
+        return { intent: input.intent, scenarios, passed: scenarios.every((scenario) => scenario.passed) };
+    },
+};

package/dist/cjs/scenario.d.ts

@@ -0,0 +1,12 @@
+import type { EconomicAdapter } from "./adapter.js";
+import type { EconomicIntent } from "./intent.js";
+import { ScenarioTrace } from "./trace.js";
+export interface ScenarioContext {
+    intent: EconomicIntent;
+    adapter: EconomicAdapter;
+    trace: ScenarioTrace;
+}
+export interface Scenario {
+    name: string;
+    run(context: ScenarioContext): Promise<void>;
+}

package/dist/cjs/scenario.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/trace.d.ts

@@ -0,0 +1,11 @@
+export type TraceType = "settlement-attempt" | "settlement-observed" | "fulfillment-attempt" | "fulfillment-observed" | "timeout" | "retry" | "callback";
+export interface TraceEntry {
+    sequence: number;
+    type: TraceType;
+    intentId: string;
+    metadata?: Record<string, string | number | boolean>;
+}
+export declare class ScenarioTrace {
+    readonly entries: TraceEntry[];
+    add(type: TraceType, intentId: string, metadata?: TraceEntry["metadata"]): void;
+}

package/dist/cjs/trace.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioTrace = void 0;
+class ScenarioTrace {
+    entries = [];
+    add(type, intentId, metadata) {
+        this.entries.push({ sequence: this.entries.length + 1, type, intentId, ...(metadata ? { metadata } : {}) });
+    }
+}
+exports.ScenarioTrace = ScenarioTrace;

package/dist/esm/adapter.d.ts

@@ -0,0 +1,9 @@
+import type { EconomicIntent } from "./intent.js";
+import type { EconomicOutcome, FulfillmentResult, SettlementResult } from "./outcome.js";
+export interface EconomicAdapter {
+    settle(intent: EconomicIntent): Promise<SettlementResult>;
+    fulfill(intent: EconomicIntent): Promise<FulfillmentResult>;
+    markComplete(intent: EconomicIntent): Promise<void>;
+    observe(intent: EconomicIntent): Promise<EconomicOutcome>;
+    reset(): Promise<void>;
+}

package/dist/esm/adapter.js

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

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./adapter.js";
+export * from "./intent.js";
+export * from "./invariant.js";
+export * from "./outcome.js";
+export * from "./reporter.js";
+export * from "./runner.js";
+export * from "./scenario.js";
+export * from "./trace.js";

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export * from "./adapter.js";
+export * from "./intent.js";
+export * from "./invariant.js";
+export * from "./outcome.js";
+export * from "./reporter.js";
+export * from "./runner.js";
+export * from "./scenario.js";
+export * from "./trace.js";

package/dist/esm/intent.d.ts

@@ -0,0 +1,18 @@
+import type { EconomicInvariant } from "./invariant.js";
+export interface EconomicIntent {
+    id: string;
+    intentId: string;
+    payment: {
+        payer: string;
+        recipient: string;
+        asset: {
+            symbol: "USDC";
+            decimals: 6;
+        };
+        amount: bigint;
+    };
+    invariants: EconomicInvariant[];
+}
+type IntentInput = Omit<EconomicIntent, "intentId">;
+export declare function defineIntent(input: IntentInput): EconomicIntent;
+export {};

package/dist/esm/intent.js

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+export function defineIntent(input) {
+    if (input.payment.amount <= 0n)
+        throw new Error("Intent amount must be positive");
+    if (!input.id.trim())
+        throw new Error("Intent ID must not be empty");
+    const intentId = createHash("sha256").update(`sazume:intent:v1:${input.id}`).digest("hex");
+    return { ...input, intentId };
+}

package/dist/esm/invariant.d.ts

@@ -0,0 +1,17 @@
+import type { EconomicIntent } from "./intent.js";
+import type { EconomicOutcome } from "./outcome.js";
+export interface InvariantResult {
+    name: string;
+    passed: boolean;
+    expected: string;
+    observed: string;
+    message?: string;
+}
+export interface EconomicInvariant {
+    name: string;
+    evaluate(intent: EconomicIntent, outcome: EconomicOutcome): InvariantResult;
+}
+export declare const settlementUniqueness: () => EconomicInvariant;
+export declare const recipientAmount: () => EconomicInvariant;
+export declare const fulfillmentUniqueness: () => EconomicInvariant;
+export declare const completionConsistency: () => EconomicInvariant;

package/dist/esm/invariant.js

@@ -0,0 +1,34 @@
+function invariant(name, evaluate) {
+    return { name, evaluate: (intent, outcome) => ({ name, ...evaluate(intent, outcome) }) };
+}
+export const settlementUniqueness = () => invariant("Settlement uniqueness", (_intent, outcome) => ({
+    passed: outcome.settlement.count <= 1,
+    expected: "<= 1",
+    observed: String(outcome.settlement.count),
+    message: outcome.settlement.count > 1 ? "One economic intent produced multiple settlements." : undefined,
+}));
+export const recipientAmount = () => invariant("Recipient amount", (intent, outcome) => {
+    const applicable = outcome.completed;
+    const passed = !applicable || outcome.settlement.totalAmount === intent.payment.amount;
+    return {
+        passed,
+        expected: `${(intent.payment.amount / 1000000n).toString()}.${(intent.payment.amount % 1000000n).toString().padStart(6, "0")} USDC`,
+        observed: `${outcome.settlement.totalAmount} base units`,
+        message: applicable && !passed ? "Completed intent did not deliver exactly the intended amount." : undefined,
+    };
+});
+export const fulfillmentUniqueness = () => invariant("Fulfillment uniqueness", (_intent, outcome) => ({
+    passed: outcome.fulfillment.count <= 1,
+    expected: "<= 1",
+    observed: String(outcome.fulfillment.count),
+    message: outcome.fulfillment.count > 1 ? "One economic intent produced multiple fulfillments." : undefined,
+}));
+export const completionConsistency = () => invariant("Completion consistency", (_intent, outcome) => {
+    const passed = !outcome.completed || (outcome.settlement.count > 0 && outcome.fulfillment.count > 0);
+    return {
+        passed,
+        expected: "completed implies settlement and fulfillment",
+        observed: `completed=${outcome.completed}, settlements=${outcome.settlement.count}, fulfillments=${outcome.fulfillment.count}`,
+        message: !passed ? "Workflow claimed completion without settlement and fulfillment." : undefined,
+    };
+});

package/dist/esm/outcome.d.ts

@@ -0,0 +1,18 @@
+export interface EconomicOutcome {
+    intentId: string;
+    settlement: {
+        count: number;
+        totalAmount: bigint;
+    };
+    fulfillment: {
+        count: number;
+    };
+    completed: boolean;
+}
+export interface SettlementResult {
+    accepted: boolean;
+    amount: bigint;
+}
+export interface FulfillmentResult {
+    accepted: boolean;
+}

package/dist/esm/outcome.js

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

package/dist/esm/reporter.d.ts

@@ -0,0 +1,2 @@
+import type { SazumeRunResult } from "./runner.js";
+export declare function report(result: SazumeRunResult, label: string): string;

package/dist/esm/reporter.js

@@ -0,0 +1,27 @@
+function formatAmount(amount) {
+    const whole = amount / 1000000n;
+    const fraction = (amount % 1000000n).toString().padStart(6, "0");
+    return `${whole}.${fraction} USDC`;
+}
+export function report(result, label) {
+    const lines = ["SAZUME", `Economic Reliability Test — ${label}`, "────────────────────────────────", ""];
+    if (label.toUpperCase() === "UNSAFE") {
+        lines.push(`Intent        ${result.intent.id}`, `Expected      ${formatAmount(result.intent.payment.amount)}`, "");
+    }
+    for (const scenario of result.scenarios) {
+        lines.push(`${scenario.passed ? "✓" : "✕"} ${scenario.scenario}`);
+        if (!scenario.passed) {
+            lines.push("", "ECONOMIC INVARIANT VIOLATION");
+            for (const item of scenario.invariants.filter((invariant) => !invariant.passed)) {
+                lines.push("", item.name, `  expected    ${item.expected}`, `  observed    ${item.name === "Recipient amount" ? formatAmount(scenario.outcome.settlement.totalAmount) : item.observed}`);
+            }
+            lines.push("", "TRACE");
+            for (const entry of scenario.trace)
+                lines.push(`  ${String(entry.sequence).padStart(2, "0")} ${entry.type}`);
+        }
+    }
+    const passed = result.scenarios.filter((scenario) => scenario.passed).length;
+    const failed = result.scenarios.length - passed;
+    lines.push("", "────────────────────────────────", `${passed} passed`, `${failed} failed`, "", result.passed ? "ECONOMIC INTENT PRESERVED" : "ECONOMIC INTENT NOT PRESERVED");
+    return lines.join("\n");
+}

package/dist/esm/runner.d.ts

@@ -0,0 +1,25 @@
+import type { EconomicAdapter } from "./adapter.js";
+import type { EconomicIntent } from "./intent.js";
+import type { InvariantResult } from "./invariant.js";
+import type { EconomicOutcome } from "./outcome.js";
+import type { Scenario } from "./scenario.js";
+import { type TraceEntry } from "./trace.js";
+export interface ScenarioResult {
+    scenario: string;
+    outcome: EconomicOutcome;
+    invariants: InvariantResult[];
+    trace: TraceEntry[];
+    passed: boolean;
+}
+export interface SazumeRunResult {
+    intent: EconomicIntent;
+    scenarios: ScenarioResult[];
+    passed: boolean;
+}
+export declare const sazume: {
+    run(input: {
+        intent: EconomicIntent;
+        adapter: EconomicAdapter;
+        scenarios: Scenario[];
+    }): Promise<SazumeRunResult>;
+};

package/dist/esm/runner.js

@@ -0,0 +1,15 @@
+import { ScenarioTrace } from "./trace.js";
+export const sazume = {
+    async run(input) {
+        const scenarios = [];
+        for (const scenario of input.scenarios) {
+            await input.adapter.reset();
+            const trace = new ScenarioTrace();
+            await scenario.run({ intent: input.intent, adapter: input.adapter, trace });
+            const outcome = await input.adapter.observe(input.intent);
+            const invariants = input.intent.invariants.map((item) => item.evaluate(input.intent, outcome));
+            scenarios.push({ scenario: scenario.name, outcome, invariants, trace: trace.entries, passed: invariants.every((item) => item.passed) });
+        }
+        return { intent: input.intent, scenarios, passed: scenarios.every((scenario) => scenario.passed) };
+    },
+};

package/dist/esm/scenario.d.ts

@@ -0,0 +1,12 @@
+import type { EconomicAdapter } from "./adapter.js";
+import type { EconomicIntent } from "./intent.js";
+import { ScenarioTrace } from "./trace.js";
+export interface ScenarioContext {
+    intent: EconomicIntent;
+    adapter: EconomicAdapter;
+    trace: ScenarioTrace;
+}
+export interface Scenario {
+    name: string;
+    run(context: ScenarioContext): Promise<void>;
+}

package/dist/esm/scenario.js

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

package/dist/esm/trace.d.ts

@@ -0,0 +1,11 @@
+export type TraceType = "settlement-attempt" | "settlement-observed" | "fulfillment-attempt" | "fulfillment-observed" | "timeout" | "retry" | "callback";
+export interface TraceEntry {
+    sequence: number;
+    type: TraceType;
+    intentId: string;
+    metadata?: Record<string, string | number | boolean>;
+}
+export declare class ScenarioTrace {
+    readonly entries: TraceEntry[];
+    add(type: TraceType, intentId: string, metadata?: TraceEntry["metadata"]): void;
+}

package/dist/esm/trace.js

@@ -0,0 +1,6 @@
+export class ScenarioTrace {
+    entries = [];
+    add(type, intentId, metadata) {
+        this.entries.push({ sequence: this.entries.length + 1, type, intentId, ...(metadata ? { metadata } : {}) });
+    }
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@sazume/core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-rc.1",
+  "license": "MIT",
+  "type": "module",
+  "description": "Economic intent, scenario, adapter, observation and invariant primitives for Sazume.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Webghost01-NG/sazume.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://sazume.vercel.app/docs",
+  "keywords": ["economic reliability", "payments", "invariants", "testing"],
+  "publishConfig": {
+    "access": "public",
+    "tag": "next",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "sideEffects": false,
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json && node scripts/mark-cjs.mjs",
+    "build": "npm run build:esm && npm run build:cjs",
+    "prepack": "npm run build"
+  }
+}