sparta_worlds 0.6.0

package/server/dist/core/world.js

@@ -0,0 +1,361 @@
+import { canonicalHash, canonicalJson } from "./canonical.js";
+import { deterministicToken, stripeId } from "./prng.js";
+export const RESOURCE_NAMES = [
+    "customers",
+    "products",
+    "prices",
+    "invoices",
+    "invoiceitems",
+    "payment_intents",
+    "charges",
+    "refunds",
+    "subscriptions",
+    "customer_balance_transactions",
+    "tickets",
+];
+export const TWIN_API_VERSION = "2024-06-20";
+export class World {
+    id;
+    db;
+    generationCounter = 0;
+    closedFlag = false;
+    constructor(id, db) {
+        this.id = id;
+        this.db = db;
+    }
+    get generation() {
+        return this.generationCounter;
+    }
+    bumpGeneration() {
+        this.generationCounter++;
+    }
+    get closed() {
+        return this.closedFlag;
+    }
+    close() {
+        if (this.closedFlag)
+            return;
+        this.closedFlag = true;
+        this.bumpGeneration();
+        this.db.close();
+    }
+    getMeta(key) {
+        const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+        return row?.value;
+    }
+    setMeta(key, value) {
+        this.db
+            .prepare("INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+            .run(key, value);
+    }
+    get seedHash() {
+        return this.getMeta("seed_hash") ?? "";
+    }
+    get seedName() {
+        return this.getMeta("seed_name") ?? "";
+    }
+    get seed() {
+        return JSON.parse(this.getMeta("seed_json") ?? "{}");
+    }
+    get clockMode() {
+        return this.getMeta("clock_mode") ?? "manual";
+    }
+    get autoTickSeconds() {
+        return Number(this.getMeta("auto_tick_seconds") ?? "1");
+    }
+    get clock() {
+        return Number(this.getMeta("clock") ?? "0");
+    }
+    setClock(seconds) {
+        this.setMeta("clock", String(seconds));
+    }
+    advanceClock(seconds) {
+        const next = this.clock + seconds;
+        this.setClock(next);
+        return next;
+    }
+    bumpCounter(metaKey) {
+        const next = Number(this.getMeta(metaKey) ?? "0") + 1;
+        this.setMeta(metaKey, String(next));
+        return next;
+    }
+    nextId(prefix) {
+        return stripeId(prefix, this.seedHash, this.bumpCounter("id_counter"));
+    }
+    nextToken(length = 16) {
+        return deterministicToken(this.seedHash, this.bumpCounter("id_counter"), length);
+    }
+    nextSeq() {
+        return this.bumpCounter("seq_counter");
+    }
+    get currentSeq() {
+        return Number(this.getMeta("seq_counter") ?? "0");
+    }
+    incrCounter(name) {
+        const row = this.db
+            .prepare("INSERT INTO counters(name, value) VALUES(?, 1) ON CONFLICT(name) DO UPDATE SET value = value + 1 RETURNING value")
+            .get(name);
+        return row.value;
+    }
+    getCounter(name) {
+        const row = this.db.prepare("SELECT value FROM counters WHERE name = ?").get(name);
+        return row?.value ?? 0;
+    }
+    insertObject(resource, data) {
+        const id = data.id;
+        if (typeof id !== "string" || id === "")
+            throw new Error(`insertObject: object has no id (resource ${resource})`);
+        const seq = this.nextSeq();
+        const created = typeof data.created === "number" ? data.created : this.clock;
+        this.db
+            .prepare("INSERT INTO objects(id, resource, data, created, created_seq, updated_seq, deleted_seq) VALUES(?, ?, ?, ?, ?, ?, NULL)")
+            .run(id, resource, JSON.stringify(data), created, seq, seq);
+    }
+    getObject(resource, id, opts = {}) {
+        const row = this.db.prepare("SELECT * FROM objects WHERE id = ? AND resource = ?").get(id, resource);
+        if (!row)
+            return undefined;
+        if (row.deleted_seq !== null && !opts.includeDeleted)
+            return undefined;
+        return { ...row, data: JSON.parse(row.data) };
+    }
+    archiveVersion(resource, id, replacedAtSeq) {
+        const row = this.db
+            .prepare("SELECT data, updated_seq FROM objects WHERE id = ? AND resource = ? AND deleted_seq IS NULL")
+            .get(id, resource);
+        if (!row)
+            return;
+        this.db
+            .prepare("INSERT INTO object_versions(id, resource, data, valid_from_seq, valid_to_seq) VALUES(?, ?, ?, ?, ?)")
+            .run(id, resource, row.data, row.updated_seq, replacedAtSeq);
+    }
+    objectAt(id, seq) {
+        const row = this.db
+            .prepare("SELECT data FROM object_versions WHERE id = ? AND valid_from_seq <= ? AND valid_to_seq > ? ORDER BY valid_to_seq ASC LIMIT 1")
+            .get(id, seq, seq);
+        return row ? JSON.parse(row.data) : undefined;
+    }
+    updateObject(resource, id, data) {
+        const seq = this.nextSeq();
+        this.archiveVersion(resource, id, seq);
+        const res = this.db
+            .prepare("UPDATE objects SET data = ?, updated_seq = ? WHERE id = ? AND resource = ? AND deleted_seq IS NULL")
+            .run(JSON.stringify(data), seq, id, resource);
+        if (res.changes === 0)
+            throw new Error(`updateObject: no live ${resource} with id ${id}`);
+    }
+    deleteObject(resource, id) {
+        const seq = this.nextSeq();
+        this.archiveVersion(resource, id, seq);
+        const res = this.db
+            .prepare("UPDATE objects SET deleted_seq = ?, updated_seq = ? WHERE id = ? AND resource = ? AND deleted_seq IS NULL")
+            .run(seq, seq, id, resource);
+        if (res.changes === 0)
+            throw new Error(`deleteObject: no live ${resource} with id ${id}`);
+    }
+    listObjects(resource) {
+        const rows = this.db
+            .prepare("SELECT * FROM objects WHERE resource = ? AND deleted_seq IS NULL ORDER BY created_seq DESC")
+            .all(resource);
+        return rows.map((r) => ({ ...r, data: JSON.parse(r.data) }));
+    }
+    emitEvent(type, object, opts = {}) {
+        const id = this.nextId("evt");
+        const seq = this.nextSeq();
+        const created = this.clock;
+        const data = {
+            id,
+            object: "event",
+            api_version: TWIN_API_VERSION,
+            created,
+            data: { object },
+            livemode: false,
+            request: { id: null, idempotency_key: opts.idempotencyKey ?? null },
+            type,
+        };
+        this.db
+            .prepare("INSERT INTO events(id, seq, type, created, data) VALUES(?, ?, ?, ?, ?)")
+            .run(id, seq, type, created, JSON.stringify(data));
+        const config = this.webhookConfig();
+        if (config) {
+            this.db
+                .prepare("INSERT INTO webhook_deliveries(seq, event_id, url, status, attempts, next_attempt_at) VALUES(?, ?, ?, 'pending', 0, ?)")
+                .run(seq, id, config.url, created);
+        }
+        return { id, seq, type, created, data };
+    }
+    listEvents(opts = {}) {
+        const rows = this.db
+            .prepare("SELECT * FROM events WHERE seq > ? ORDER BY seq ASC")
+            .all(opts.afterSeq ?? -1);
+        return rows.map((r) => ({ ...r, data: JSON.parse(r.data) }));
+    }
+    getEvent(id) {
+        const row = this.db.prepare("SELECT * FROM events WHERE id = ?").get(id);
+        return row ? { ...row, data: JSON.parse(row.data) } : undefined;
+    }
+    pendingWebhooksFor(eventId) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS n FROM webhook_deliveries WHERE event_id = ? AND status = 'pending'")
+            .get(eventId);
+        return row.n;
+    }
+    logRequest(entry) {
+        this.db
+            .prepare("INSERT INTO request_log(method, path, status, injected, matched, unsupported, clock) VALUES(?, ?, ?, ?, ?, ?, ?)")
+            .run(entry.method, entry.path, entry.status, entry.injected ? 1 : 0, entry.matched === false ? 0 : 1, entry.unsupported ?? null, this.clock);
+    }
+    listRequests(opts = {}) {
+        const where = opts.unmatchedOnly ? "WHERE matched = 0 OR unsupported IS NOT NULL" : "";
+        return this.db.prepare(`SELECT * FROM request_log ${where} ORDER BY seq ASC`).all();
+    }
+    webhookConfig() {
+        const row = this.db
+            .prepare("SELECT url, secret, max_retries, auto_deliver, signature_time FROM webhook_config WHERE id = 1")
+            .get();
+        return row;
+    }
+    setWebhookConfig(url, maxRetries = 3, autoDeliver = true, signatureTime = "wall") {
+        const secret = `whsec_twin_${deterministicToken(this.seedHash, 0, 24)}`;
+        this.db
+            .prepare("INSERT INTO webhook_config(id, url, secret, max_retries, auto_deliver, signature_time) VALUES(1, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET url = excluded.url, max_retries = excluded.max_retries, auto_deliver = excluded.auto_deliver, signature_time = excluded.signature_time")
+            .run(url, secret, maxRetries, autoDeliver ? 1 : 0, signatureTime);
+        return this.webhookConfig();
+    }
+    clearWebhookConfig() {
+        this.db.prepare("DELETE FROM webhook_config WHERE id = 1").run();
+    }
+    listDeliveries() {
+        return this.db.prepare("SELECT * FROM webhook_deliveries ORDER BY seq ASC").all();
+    }
+    getIdempotency(key) {
+        return this.db.prepare("SELECT method, path, params_hash, status, body FROM idempotency WHERE key = ?").get(key);
+    }
+    putIdempotency(key, method, path, paramsHash, status, body) {
+        this.db
+            .prepare("INSERT OR IGNORE INTO idempotency(key, method, path, params_hash, status, body, created) VALUES(?, ?, ?, ?, ?, ?, ?)")
+            .run(key, method, path, paramsHash, status, body, this.clock);
+    }
+    addApiKey(key) {
+        this.db.prepare("INSERT OR IGNORE INTO api_keys(key) VALUES(?)").run(key);
+    }
+    checkApiKey(key) {
+        const row = this.db.prepare("SELECT expired FROM api_keys WHERE key = ?").get(key);
+        if (!row)
+            return "unknown";
+        return row.expired ? "expired" : "ok";
+    }
+    bumpApiKeyUse(key) {
+        const row = this.db
+            .prepare("UPDATE api_keys SET requests_used = requests_used + 1 WHERE key = ? RETURNING requests_used")
+            .get(key);
+        return row?.requests_used ?? 0;
+    }
+    expireApiKey(key) {
+        this.db.prepare("UPDATE api_keys SET expired = 1 WHERE key = ?").run(key);
+    }
+    listApiKeys() {
+        return this.db.prepare("SELECT key FROM api_keys ORDER BY key").all().map((r) => r.key);
+    }
+    addAdminToken(token) {
+        this.db.prepare("INSERT OR IGNORE INTO admin_tokens(token) VALUES(?)").run(token);
+    }
+    hasAdminToken(token) {
+        return this.db.prepare("SELECT 1 AS one FROM admin_tokens WHERE token = ?").get(token) !== undefined;
+    }
+    revokeAdminToken(token) {
+        return this.db.prepare("DELETE FROM admin_tokens WHERE token = ?").run(token).changes > 0;
+    }
+    countAdminTokens() {
+        return this.db.prepare("SELECT COUNT(*) AS n FROM admin_tokens").get().n;
+    }
+    setScenario(doc) {
+        if (doc === null) {
+            this.db.prepare("DELETE FROM scenario WHERE id = 1").run();
+            this.db.prepare("DELETE FROM counters WHERE name LIKE 'scenario:%'").run();
+        }
+        else {
+            this.db
+                .prepare("INSERT INTO scenario(id, doc) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET doc = excluded.doc")
+                .run(JSON.stringify(doc));
+            this.db.prepare("DELETE FROM counters WHERE name LIKE 'scenario:%'").run();
+        }
+    }
+    getScenario() {
+        const row = this.db.prepare("SELECT doc FROM scenario WHERE id = 1").get();
+        return row ? JSON.parse(row.doc) : undefined;
+    }
+    setMark(name) {
+        const seq = this.currentSeq;
+        const clock = this.clock;
+        this.db
+            .prepare("INSERT INTO marks(name, seq, clock) VALUES(?, ?, ?) ON CONFLICT(name) DO UPDATE SET seq = excluded.seq, clock = excluded.clock")
+            .run(name, seq, clock);
+        return { name, seq, clock };
+    }
+    getMark(name) {
+        return this.db.prepare("SELECT name, seq, clock FROM marks WHERE name = ?").get(name);
+    }
+    listMarks() {
+        return this.db.prepare("SELECT name, seq, clock FROM marks ORDER BY seq ASC, name ASC").all();
+    }
+    diff(fromSeq) {
+        const created = {};
+        const updated = {};
+        const deleted = {};
+        const before = {};
+        const rows = this.db
+            .prepare("SELECT * FROM objects WHERE updated_seq > ? ORDER BY resource ASC, created_seq ASC")
+            .all(fromSeq);
+        for (const row of rows) {
+            const data = JSON.parse(row.data);
+            const existedAtMark = row.created_seq <= fromSeq;
+            const isDeleted = row.deleted_seq !== null && row.deleted_seq > fromSeq;
+            if (!existedAtMark && isDeleted)
+                continue;
+            const bucket = !existedAtMark ? created : isDeleted ? deleted : updated;
+            (bucket[row.resource] ??= []).push(data);
+            if (existedAtMark) {
+                const image = this.objectAt(row.id, fromSeq);
+                if (!image)
+                    throw new Error(`diff: no version of ${row.id} covers seq ${fromSeq}`);
+                (before[row.resource] ??= {})[row.id] = image;
+            }
+        }
+        return { created, updated, deleted, before };
+    }
+    dump() {
+        const objects = this.db
+            .prepare("SELECT id, resource, data, created, created_seq, updated_seq, deleted_seq FROM objects ORDER BY created_seq ASC")
+            .all();
+        const events = this.db.prepare("SELECT id, seq, type, created, data FROM events ORDER BY seq ASC").all();
+        const idempotency = this.db
+            .prepare("SELECT key, method, path, params_hash, status, body, created FROM idempotency ORDER BY key ASC")
+            .all();
+        const counters = this.db.prepare("SELECT name, value FROM counters ORDER BY name ASC").all();
+        const marks = this.listMarks();
+        const deliveries = this.db
+            .prepare("SELECT seq, event_id, url, status, attempts, next_attempt_at, last_status_code FROM webhook_deliveries ORDER BY seq ASC")
+            .all();
+        const requests = this.db
+            .prepare("SELECT seq, method, path, status, injected, matched, unsupported, clock FROM request_log ORDER BY seq ASC")
+            .all();
+        return canonicalJson({
+            seed_hash: this.seedHash,
+            seed_name: this.seedName,
+            clock: this.clock,
+            id_counter: Number(this.getMeta("id_counter") ?? "0"),
+            seq_counter: this.currentSeq,
+            objects: objects.map((o) => ({ ...o, data: JSON.parse(o.data) })),
+            events: events.map((e) => ({ ...e, data: JSON.parse(e.data) })),
+            idempotency,
+            counters,
+            marks,
+            webhook_deliveries: deliveries,
+            request_log: requests,
+        });
+    }
+    dumpHash() {
+        return canonicalHash(this.dump());
+    }
+}

package/server/dist/index.js

@@ -0,0 +1,17 @@
+export { authOptionsFromEnv, describeAuth, isLoopbackHost, OPERATOR_TOKEN_MIN_LENGTH, requiredScope, resolveAuthMode, } from "./admin/auth.js";
+export { ADMIN_ENDPOINTS } from "./admin/schemas.js";
+export { buildServer } from "./app.js";
+export { canonicalHash, canonicalJson, sha256Hex } from "./core/canonical.js";
+export { StripeError } from "./core/errors.js";
+export { WorldManager, WorldNotFoundError, WorldRefusedError, WorldSchemaMismatchError, WorldUnreadableError, } from "./core/manager.js";
+export { summarizeMoney } from "./core/money.js";
+export { resolveBundledDir, resolveDataDir, resolveLibraryDirs, resolveUserDir, } from "./core/paths.js";
+export { PROTOCOL_VERSION } from "./core/protocol.js";
+export { normalizePublicUrl, resolvePublicUrl } from "./core/publicUrl.js";
+export { createLayeredSeedLibrary, createSeedLibrary, parseSeed, SeedSchema, SeedValidationError, seedHash, } from "./core/seed.js";
+export { exportSeed } from "./core/seedExport.js";
+export { addInterval, parseDuration } from "./core/time.js";
+export { RESOURCE_NAMES, TWIN_API_VERSION, World } from "./core/world.js";
+export { parseScenario, ScenarioSchema } from "./scenario/engine.js";
+export { createLayeredScenarioLibrary, createScenarioLibrary, } from "./scenario/library.js";
+export { signPayload } from "./webhooks/dispatcher.js";

package/server/dist/main.js

@@ -0,0 +1,42 @@
+import { authOptionsFromEnv, describeAuth } from "./admin/auth.js";
+import { buildServer } from "./app.js";
+const port = Number(process.env.PORT ?? process.env.WORLDS_PORT ?? 4242);
+const host = process.env.WORLDS_HOST ?? "127.0.0.1";
+const publicUrl = process.env.WORLDS_PUBLIC_URL || undefined;
+let server;
+try {
+    server = buildServer({
+        dataDir: process.env.WORLDS_DATA_DIR,
+        seedsDir: process.env.WORLDS_SEEDS_DIR,
+        scenariosDir: process.env.WORLDS_SCENARIOS_DIR,
+        publicUrl,
+        trustProxy: process.env.WORLDS_TRUST_PROXY === "1",
+        auth: authOptionsFromEnv(),
+        logger: process.env.WORLDS_LOG === "1",
+    });
+}
+catch (err) {
+    console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+}
+server
+    .listen(port, host)
+    .then((address) => {
+    console.log(`worlds server listening at ${address}`);
+    console.log(`  twin API    ${address}/v1/*  (Stripe-compatible; auth with a world API key)`);
+    console.log(`  admin API   ${address}/admin/*`);
+    console.log(`  public URL  ${server.publicUrl()}${publicUrl ? "  (WORLDS_PUBLIC_URL)" : ""}`);
+    console.log(`  ${describeAuth(server.auth())}`);
+    const refused = server.manager.refusedFiles().length;
+    if (refused > 0)
+        console.log(`  ${refused} world file(s) this runtime refuses — run: worlds world ls`);
+})
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+        void server.close().then(() => process.exit(0));
+    });
+}

package/server/dist/scenario/engine.js

@@ -0,0 +1,172 @@
+import { z } from "zod";
+import { scenarioError } from "../core/errors.js";
+export const RequestMatchSchema = z
+    .object({
+    method: z
+        .enum(["GET", "POST", "DELETE", "PUT", "PATCH"])
+        .optional()
+        .describe("HTTP method to match. Omitted = any method."),
+    path: z
+        .string()
+        .optional()
+        .describe('Path glob, e.g. "/v1/customers/*". "*" matches exactly one path segment, "**" the rest. Omitted = any path.'),
+})
+    .strict();
+export const RequestRuleSchema = z
+    .object({
+    match: RequestMatchSchema.describe("Which twin requests this rule applies to."),
+    after_requests: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe("This many matched requests pass through untouched before the rule activates."),
+    duration_requests: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("How many matched requests the rule applies to once active. Omitted = forever."),
+    every_nth: z
+        .number()
+        .int()
+        .min(2)
+        .optional()
+        .describe("Instead of a contiguous window: apply to every nth matched request (counted after after_requests)."),
+    respond: z
+        .object({
+        status: z.number().int().min(400).max(599).describe("HTTP status to inject."),
+        stripe_error: z
+            .string()
+            .default("api_error")
+            .describe("Stripe error kind: rate_limit (a 429 official SDKs surface), lock_timeout (a 429 with Stripe-Should-Retry: true, which official SDKs retry), api_error, invalid_api_key, api_key_expired."),
+    })
+        .strict()
+        .optional()
+        .describe("Inject this error response instead of executing the request. Injection happens BEFORE the handler: state is never half-mutated."),
+    latency_ms: z
+        .number()
+        .int()
+        .min(0)
+        .max(30_000)
+        .optional()
+        .describe("Delay the request by this many wall-clock milliseconds (the logical clock is unaffected)."),
+})
+    .strict();
+export const WebhookRuleSchema = z
+    .object({
+    webhooks: z
+        .object({
+        drop_every_nth: z
+            .number()
+            .int()
+            .min(2)
+            .optional()
+            .describe("Every nth delivery is silently dropped (never sent, no retries)."),
+        reorder: z
+            .enum(["swap_adjacent"])
+            .optional()
+            .describe("swap_adjacent: within each flush batch, deliveries are dispatched pairwise swapped."),
+    })
+        .strict(),
+})
+    .strict();
+export const AuthRuleSchema = z
+    .object({
+    auth: z
+        .object({
+        expire_after_requests: z
+            .number()
+            .int()
+            .min(0)
+            .describe("After this many authenticated twin requests, the API key acts expired (401 api_key_expired)."),
+    })
+        .strict(),
+})
+    .strict();
+export const ScenarioSchema = z
+    .object({
+    name: z
+        .string()
+        .regex(/^[a-z0-9][a-z0-9-]*$/)
+        .describe("Scenario name (kebab-case)."),
+    description: z.string().optional().describe("Human-readable summary, shown by `worlds scenario ls`."),
+    rules: z
+        .array(z.union([RequestRuleSchema, WebhookRuleSchema, AuthRuleSchema]))
+        .min(1)
+        .describe("Rules evaluated deterministically per request; counters live in world state."),
+})
+    .strict();
+export function parseScenario(doc) {
+    return ScenarioSchema.parse(doc);
+}
+export function matchPath(pattern, path) {
+    const pat = pattern.split("/").filter((s) => s !== "");
+    const segs = path
+        .split("?")[0]
+        .split("/")
+        .filter((s) => s !== "");
+    let i = 0;
+    for (; i < pat.length; i++) {
+        if (pat[i] === "**")
+            return true;
+        if (i >= segs.length)
+            return false;
+        if (pat[i] !== "*" && pat[i] !== segs[i])
+            return false;
+    }
+    return i === segs.length;
+}
+export function evaluateRequestRules(world, method, path) {
+    const doc = world.getScenario();
+    const outcome = { latencyMs: 0 };
+    if (!doc)
+        return outcome;
+    const scenario = doc;
+    scenario.rules.forEach((rule, idx) => {
+        if (!("match" in rule))
+            return;
+        const r = rule;
+        if (r.match.method && r.match.method !== method)
+            return;
+        if (r.match.path && !matchPath(r.match.path, path))
+            return;
+        const count = world.incrCounter(`scenario:rule:${idx}`);
+        const past = count - r.after_requests;
+        const active = past > 0 &&
+            (r.every_nth !== undefined
+                ? past % r.every_nth === 0
+                : r.duration_requests === undefined || past <= r.duration_requests);
+        if (!active)
+            return;
+        if (r.latency_ms)
+            outcome.latencyMs = Math.max(outcome.latencyMs, r.latency_ms);
+        if (r.respond && !outcome.inject) {
+            outcome.inject = scenarioError(r.respond.status, r.respond.stripe_error);
+        }
+    });
+    return outcome;
+}
+export function authExpiryThreshold(world) {
+    const doc = world.getScenario();
+    if (!doc)
+        return undefined;
+    const scenario = doc;
+    for (const rule of scenario.rules) {
+        if ("auth" in rule)
+            return rule.auth.expire_after_requests;
+    }
+    return undefined;
+}
+export function webhookRules(world) {
+    const doc = world.getScenario();
+    if (!doc)
+        return {};
+    const scenario = doc;
+    for (const rule of scenario.rules) {
+        if ("webhooks" in rule) {
+            return { dropEveryNth: rule.webhooks.drop_every_nth, reorder: rule.webhooks.reorder };
+        }
+    }
+    return {};
+}

package/server/dist/scenario/library.js

@@ -0,0 +1,49 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { parseScenario } from "./engine.js";
+export function createScenarioLibrary(dir) {
+    function load() {
+        const out = new Map();
+        if (!existsSync(dir))
+            return out;
+        for (const file of readdirSync(dir)
+            .filter((f) => /\.(ya?ml|json)$/.test(f))
+            .sort()) {
+            try {
+                const raw = readFileSync(join(dir, file), "utf8");
+                const doc = file.endsWith(".json") ? JSON.parse(raw) : parseYaml(raw);
+                const scenario = parseScenario(doc);
+                out.set(scenario.name, { name: scenario.name, file: join(dir, file), scenario });
+            }
+            catch {
+            }
+        }
+        return out;
+    }
+    return {
+        list: () => [...load().values()],
+        get: (name) => load().get(name)?.scenario,
+    };
+}
+export function createLayeredScenarioLibrary(dirs) {
+    const layers = dirs.map((dir) => createScenarioLibrary(dir));
+    return {
+        dirs,
+        list() {
+            const merged = new Map();
+            for (const layer of layers)
+                for (const entry of layer.list())
+                    merged.set(entry.name, entry);
+            return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+        },
+        get(name) {
+            for (let i = layers.length - 1; i >= 0; i--) {
+                const hit = layers[i].get(name);
+                if (hit)
+                    return hit;
+            }
+            return undefined;
+        },
+    };
+}