@yiaany/ghostapi 0.1.9 → 0.2.1

package/dist/worlds/worlds.js

@@ -2,8 +2,8 @@ import { createHash } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { getDataPaths } from "../config/dataPaths.js";
-import { isSecretFieldName, sanitizeSecretString } from "../security/secrets.js";
-import { atomicWriteJson, ensurePrivateDirectory, withFileLock } from "../storage/fileStore.js";
+import { isSecretFieldName, sanitizeSecretString, } from "../security/secrets.js";
+import { atomicWriteJson, ensurePrivateDirectory, withFileLock, } from "../storage/fileStore.js";
 const WORLD_SCHEMA_VERSION = 1;
 const WORLD_KIND = "ghostapi.world";
 const WORLD_VERSION = "1.0.0";
@@ -35,22 +35,62 @@ export function createSyntheticWorld(options) {
         version: WORLD_VERSION,
         seed,
         clock: { initialAt, timezone: "UTC" },
-        personas: [{ id: personaId, displayName: `Operator ${suffix.toUpperCase()}`, handle: `operator-${suffix}` }],
-        organizations: [{ id: organizationId, name: `Sandbox ${suffix.toUpperCase()}`, slug }],
+        personas: [
+            {
+                id: personaId,
+                displayName: `Operator ${suffix.toUpperCase()}`,
+                handle: `operator-${suffix}`,
+            },
+        ],
+        organizations: [
+            { id: organizationId, name: `Sandbox ${suffix.toUpperCase()}`, slug },
+        ],
         accounts: {
-            stripe: { accountId: `acct_world_${suffix}`, customerPrefix: `cus_world_${suffix}` },
-            github: { userLogin: `world-${suffix}`, owner: `sandbox-${suffix}`, repository: `integration-${suffix}` },
-            email: { domain: "ghostapi.invalid", inboxAddress: `operator-${suffix}@ghostapi.invalid` },
-            genericRest: { tenantId: `tenant_world_${suffix}`, basePath: `/tenants/tenant_world_${suffix}` }
+            stripe: {
+                accountId: `acct_world_${suffix}`,
+                customerPrefix: `cus_world_${suffix}`,
+            },
+            github: {
+                userLogin: `world-${suffix}`,
+                owner: `sandbox-${suffix}`,
+                repository: `integration-${suffix}`,
+            },
+            email: {
+                domain: "ghostapi.invalid",
+                inboxAddress: `operator-${suffix}@ghostapi.invalid`,
+            },
+            genericRest: {
+                tenantId: `tenant_world_${suffix}`,
+                basePath: `/tenants/tenant_world_${suffix}`,
+            },
+        },
+        resources: {
+            defaultPriceId: `price_world_${suffix}`,
+            recoveryIssueLabel: "payment-recovery",
         },
-        resources: { defaultPriceId: `price_world_${suffix}`, recoveryIssueLabel: "payment-recovery" },
         relationships: [{ personaId, organizationId, role: "owner" }],
         providerProjections: {
-            stripe: { personaId, organizationId, customerPrefix: `cus_world_${suffix}` },
-            github: { personaId, organizationId, repository: `sandbox-${suffix}/integration-${suffix}` },
-            email: { personaId, organizationId, inboxAddress: `operator-${suffix}@ghostapi.invalid` },
-            genericRest: { personaId, organizationId, tenantId: `tenant_world_${suffix}` }
-        }
+            stripe: {
+                personaId,
+                organizationId,
+                customerPrefix: `cus_world_${suffix}`,
+            },
+            github: {
+                personaId,
+                organizationId,
+                repository: `sandbox-${suffix}/integration-${suffix}`,
+            },
+            email: {
+                personaId,
+                organizationId,
+                inboxAddress: `operator-${suffix}@ghostapi.invalid`,
+            },
+            genericRest: {
+                personaId,
+                organizationId,
+                tenantId: `tenant_world_${suffix}`,
+            },
+        },
     };
     const initialState = {
         clockAt: initialAt,
@@ -58,9 +98,16 @@ export function createSyntheticWorld(options) {
         github: { issues: [] },
         email: { messages: [] },
         genericRest: { failures: [] },
-        receipts: []
+        receipts: [],
     };
-    return validateSyntheticWorld({ schemaVersion: WORLD_SCHEMA_VERSION, kind: WORLD_KIND, manifest, revision: 0, baseline: initialState, state: initialState });
+    return validateSyntheticWorld({
+        schemaVersion: WORLD_SCHEMA_VERSION,
+        kind: WORLD_KIND,
+        manifest,
+        revision: 0,
+        baseline: initialState,
+        state: initialState,
+    });
 }
 export async function createWorld(options) {
     const world = createSyntheticWorld(options);
@@ -81,7 +128,7 @@ export async function resetWorld(id) {
     return mutateWorld(normalizeIdentifier(id, "World id"), (world) => ({
         ...world,
         revision: world.revision + 1,
-        state: structuredClone(world.baseline)
+        state: structuredClone(world.baseline),
     }));
 }
 export async function forkWorld(sourceId, options) {
@@ -92,7 +139,10 @@ export async function forkWorld(sourceId, options) {
     const fork = structuredClone(source);
     fork.manifest.id = id;
     fork.manifest.title = title;
-    fork.manifest.lineage = { parentId: source.manifest.id, parentRevision: source.revision };
+    fork.manifest.lineage = {
+        parentId: source.manifest.id,
+        parentRevision: source.revision,
+    };
     fork.revision = 0;
     fork.baseline = structuredClone(source.state);
     fork.state = structuredClone(source.state);
@@ -131,18 +181,65 @@ export async function runSubscriptionFailureWorkflow(id, actionId, commit) {
             emailId,
             issueNumber: world.state.github.issues.length + 1,
             genericFailureId,
-            completedAt: nextTimestamp(world.state.clockAt)
+            completedAt: nextTimestamp(world.state.clockAt),
         };
         const nextState = {
             clockAt: receipt.completedAt,
             stripe: {
-                customers: [...world.state.stripe.customers, { id: customerId, personaId: persona.id, organizationId: organization.id }],
-                subscriptions: [...world.state.stripe.subscriptions, { id: subscriptionId, customerId, priceId: world.manifest.resources.defaultPriceId, status: "past_due", failureCode: "card_declined" }]
+                customers: [
+                    ...world.state.stripe.customers,
+                    {
+                        id: customerId,
+                        personaId: persona.id,
+                        organizationId: organization.id,
+                    },
+                ],
+                subscriptions: [
+                    ...world.state.stripe.subscriptions,
+                    {
+                        id: subscriptionId,
+                        customerId,
+                        priceId: world.manifest.resources.defaultPriceId,
+                        status: "past_due",
+                        failureCode: "card_declined",
+                    },
+                ],
+            },
+            github: {
+                issues: [
+                    ...world.state.github.issues,
+                    {
+                        number: receipt.issueNumber,
+                        repository: world.manifest.providerProjections.github.repository,
+                        title: `Recover ${subscriptionId}`,
+                        status: "open",
+                        relatedSubscriptionId: subscriptionId,
+                    },
+                ],
             },
-            github: { issues: [...world.state.github.issues, { number: receipt.issueNumber, repository: world.manifest.providerProjections.github.repository, title: `Recover ${subscriptionId}`, status: "open", relatedSubscriptionId: subscriptionId }] },
-            email: { messages: [...world.state.email.messages, { id: emailId, to: world.manifest.accounts.email.inboxAddress, template: "subscription-payment-failed", relatedSubscriptionId: subscriptionId }] },
-            genericRest: { failures: [...world.state.genericRest.failures, { id: genericFailureId, tenantId: world.manifest.accounts.genericRest.tenantId, code: "payment_failed", relatedSubscriptionId: subscriptionId }] },
-            receipts: [...world.state.receipts, receipt]
+            email: {
+                messages: [
+                    ...world.state.email.messages,
+                    {
+                        id: emailId,
+                        to: world.manifest.accounts.email.inboxAddress,
+                        template: "subscription-payment-failed",
+                        relatedSubscriptionId: subscriptionId,
+                    },
+                ],
+            },
+            genericRest: {
+                failures: [
+                    ...world.state.genericRest.failures,
+                    {
+                        id: genericFailureId,
+                        tenantId: world.manifest.accounts.genericRest.tenantId,
+                        code: "payment_failed",
+                        relatedSubscriptionId: subscriptionId,
+                    },
+                ],
+            },
+            receipts: [...world.state.receipts, receipt],
         };
         return { ...world, revision: world.revision + 1, state: nextState };
     }, commit);
@@ -163,7 +260,7 @@ export function formatWorld(world) {
         `Persona: ${world.manifest.personas[0].id}`,
         `Organization: ${world.manifest.organizations[0].id}`,
         `Providers: stripe, github, email, generic-rest`,
-        `Workflow receipts: ${world.state.receipts.length}`
+        `Workflow receipts: ${world.state.receipts.length}`,
     ].join("\n");
 }
 export function validateSyntheticWorld(value) {
@@ -171,12 +268,21 @@ export function validateSyntheticWorld(value) {
     assertExactKeys(root, ["schemaVersion", "kind", "manifest", "revision", "baseline", "state"], "Synthetic world");
     if (root.schemaVersion !== WORLD_SCHEMA_VERSION || root.kind !== WORLD_KIND)
         throw new SyntheticWorldError("Unsupported synthetic world schema.");
-    if (!Number.isInteger(root.revision) || root.revision < 0 || root.revision > 1_000_000)
+    if (!Number.isInteger(root.revision) ||
+        root.revision < 0 ||
+        root.revision > 1_000_000)
         throw new SyntheticWorldError("Synthetic world revision is invalid.");
     const manifest = normalizeManifest(root.manifest);
     const baseline = normalizeState(root.baseline, manifest);
     const state = normalizeState(root.state, manifest);
-    const world = { schemaVersion: 1, kind: "ghostapi.world", manifest, revision: root.revision, baseline, state };
+    const world = {
+        schemaVersion: 1,
+        kind: "ghostapi.world",
+        manifest,
+        revision: root.revision,
+        baseline,
+        state,
+    };
     assertWorldSize(world);
     return world;
 }
@@ -224,7 +330,20 @@ async function ensureWorldFileIsSafe(path, required) {
 }
 function normalizeManifest(value) {
     const manifest = readObject(value, "Synthetic world manifest is invalid.");
-    assertExactKeys(manifest, ["id", "title", "version", "seed", "clock", "personas", "organizations", "accounts", "resources", "relationships", "providerProjections", "lineage"], "Synthetic world manifest");
+    assertExactKeys(manifest, [
+        "id",
+        "title",
+        "version",
+        "seed",
+        "clock",
+        "personas",
+        "organizations",
+        "accounts",
+        "resources",
+        "relationships",
+        "providerProjections",
+        "lineage",
+    ], "Synthetic world manifest");
     const id = normalizeIdentifier(manifest.id, "World id");
     const title = normalizeTitle(manifest.title);
     if (manifest.version !== WORLD_VERSION)
@@ -240,22 +359,49 @@ function normalizeManifest(value) {
     const resources = normalizeResources(manifest.resources);
     const relationships = normalizeRelationships(manifest.relationships, personas[0].id, organizations[0].id);
     const providerProjections = normalizeProjections(manifest.providerProjections, personas[0].id, organizations[0].id, accounts);
-    const lineage = manifest.lineage === undefined ? undefined : normalizeLineage(manifest.lineage);
-    return { id, title, version: WORLD_VERSION, seed, clock: { initialAt: clock.initialAt, timezone: "UTC" }, personas, organizations, accounts, resources, relationships, providerProjections, ...(lineage === undefined ? {} : { lineage }) };
+    const lineage = manifest.lineage === undefined
+        ? undefined
+        : normalizeLineage(manifest.lineage);
+    return {
+        id,
+        title,
+        version: WORLD_VERSION,
+        seed,
+        clock: { initialAt: clock.initialAt, timezone: "UTC" },
+        personas,
+        organizations,
+        accounts,
+        resources,
+        relationships,
+        providerProjections,
+        ...(lineage === undefined ? {} : { lineage }),
+    };
 }
 function normalizePersonas(value) {
     if (!Array.isArray(value) || value.length !== 1)
         throw new SyntheticWorldError("Synthetic world requires exactly one synthetic persona.");
     const persona = readObject(value[0], "Synthetic persona is invalid.");
     assertExactKeys(persona, ["id", "displayName", "handle"], "Synthetic persona");
-    return [{ id: normalizeIdentifier(persona.id, "Synthetic persona id"), displayName: normalizeSafeText(persona.displayName, "Synthetic persona displayName", 80), handle: normalizeIdentifier(persona.handle, "Synthetic persona handle") }];
+    return [
+        {
+            id: normalizeIdentifier(persona.id, "Synthetic persona id"),
+            displayName: normalizeSafeText(persona.displayName, "Synthetic persona displayName", 80),
+            handle: normalizeIdentifier(persona.handle, "Synthetic persona handle"),
+        },
+    ];
 }
 function normalizeOrganizations(value) {
     if (!Array.isArray(value) || value.length !== 1)
         throw new SyntheticWorldError("Synthetic world requires exactly one synthetic organization.");
     const organization = readObject(value[0], "Synthetic organization is invalid.");
     assertExactKeys(organization, ["id", "name", "slug"], "Synthetic organization");
-    return [{ id: normalizeIdentifier(organization.id, "Synthetic organization id"), name: normalizeSafeText(organization.name, "Synthetic organization name", 80), slug: normalizeIdentifier(organization.slug, "Synthetic organization slug") }];
+    return [
+        {
+            id: normalizeIdentifier(organization.id, "Synthetic organization id"),
+            name: normalizeSafeText(organization.name, "Synthetic organization name", 80),
+            slug: normalizeIdentifier(organization.slug, "Synthetic organization slug"),
+        },
+    ];
 }
 function normalizeAccounts(value) {
     const accounts = readObject(value, "Synthetic world accounts are invalid.");
@@ -273,23 +419,38 @@ function normalizeAccounts(value) {
     if (domain !== "ghostapi.invalid")
         throw new SyntheticWorldError("Synthetic world email addresses must use ghostapi.invalid.");
     return {
-        stripe: { accountId: normalizeIdentifier(stripe.accountId, "Synthetic Stripe account id"), customerPrefix: normalizeIdentifier(stripe.customerPrefix, "Synthetic Stripe customer prefix") },
-        github: { userLogin: normalizeIdentifier(github.userLogin, "Synthetic GitHub login"), owner: normalizeIdentifier(github.owner, "Synthetic GitHub owner"), repository: normalizeIdentifier(github.repository, "Synthetic GitHub repository") },
+        stripe: {
+            accountId: normalizeIdentifier(stripe.accountId, "Synthetic Stripe account id"),
+            customerPrefix: normalizeIdentifier(stripe.customerPrefix, "Synthetic Stripe customer prefix"),
+        },
+        github: {
+            userLogin: normalizeIdentifier(github.userLogin, "Synthetic GitHub login"),
+            owner: normalizeIdentifier(github.owner, "Synthetic GitHub owner"),
+            repository: normalizeIdentifier(github.repository, "Synthetic GitHub repository"),
+        },
         email: { domain, inboxAddress },
-        genericRest: { tenantId: normalizeIdentifier(genericRest.tenantId, "Synthetic tenant id"), basePath: normalizeBasePath(genericRest.basePath) }
+        genericRest: {
+            tenantId: normalizeIdentifier(genericRest.tenantId, "Synthetic tenant id"),
+            basePath: normalizeBasePath(genericRest.basePath),
+        },
     };
 }
 function normalizeResources(value) {
     const resources = readObject(value, "Synthetic world resources are invalid.");
     assertExactKeys(resources, ["defaultPriceId", "recoveryIssueLabel"], "Synthetic world resources");
-    return { defaultPriceId: normalizeIdentifier(resources.defaultPriceId, "Synthetic price id"), recoveryIssueLabel: normalizeIdentifier(resources.recoveryIssueLabel, "Synthetic issue label") };
+    return {
+        defaultPriceId: normalizeIdentifier(resources.defaultPriceId, "Synthetic price id"),
+        recoveryIssueLabel: normalizeIdentifier(resources.recoveryIssueLabel, "Synthetic issue label"),
+    };
 }
 function normalizeRelationships(value, personaId, organizationId) {
     if (!Array.isArray(value) || value.length !== 1)
         throw new SyntheticWorldError("Synthetic world requires one persona-to-organization relationship.");
     const relationship = readObject(value[0], "Synthetic world relationship is invalid.");
     assertExactKeys(relationship, ["personaId", "organizationId", "role"], "Synthetic world relationship");
-    if (relationship.personaId !== personaId || relationship.organizationId !== organizationId || relationship.role !== "owner")
+    if (relationship.personaId !== personaId ||
+        relationship.organizationId !== organizationId ||
+        relationship.role !== "owner")
         throw new SyntheticWorldError("Synthetic world relationship does not match canonical identity.");
     return [{ personaId, organizationId, role: "owner" }];
 }
@@ -304,17 +465,54 @@ function normalizeProjections(value, personaId, organizationId, accounts) {
     assertExactKeys(github, ["personaId", "organizationId", "repository"], "Synthetic GitHub projection");
     assertExactKeys(email, ["personaId", "organizationId", "inboxAddress"], "Synthetic email projection");
     assertExactKeys(genericRest, ["personaId", "organizationId", "tenantId"], "Synthetic generic REST projection");
-    if (stripe.personaId !== personaId || stripe.organizationId !== organizationId || stripe.customerPrefix !== accounts.stripe.customerPrefix || github.personaId !== personaId || github.organizationId !== organizationId || github.repository !== `${accounts.github.owner}/${accounts.github.repository}` || email.personaId !== personaId || email.organizationId !== organizationId || email.inboxAddress !== accounts.email.inboxAddress || genericRest.personaId !== personaId || genericRest.organizationId !== organizationId || genericRest.tenantId !== accounts.genericRest.tenantId) {
+    if (stripe.personaId !== personaId ||
+        stripe.organizationId !== organizationId ||
+        stripe.customerPrefix !== accounts.stripe.customerPrefix ||
+        github.personaId !== personaId ||
+        github.organizationId !== organizationId ||
+        github.repository !==
+            `${accounts.github.owner}/${accounts.github.repository}` ||
+        email.personaId !== personaId ||
+        email.organizationId !== organizationId ||
+        email.inboxAddress !== accounts.email.inboxAddress ||
+        genericRest.personaId !== personaId ||
+        genericRest.organizationId !== organizationId ||
+        genericRest.tenantId !== accounts.genericRest.tenantId) {
         throw new SyntheticWorldError("Provider projections do not match canonical synthetic identity.");
     }
-    return { stripe: { personaId, organizationId, customerPrefix: accounts.stripe.customerPrefix }, github: { personaId, organizationId, repository: `${accounts.github.owner}/${accounts.github.repository}` }, email: { personaId, organizationId, inboxAddress: accounts.email.inboxAddress }, genericRest: { personaId, organizationId, tenantId: accounts.genericRest.tenantId } };
+    return {
+        stripe: {
+            personaId,
+            organizationId,
+            customerPrefix: accounts.stripe.customerPrefix,
+        },
+        github: {
+            personaId,
+            organizationId,
+            repository: `${accounts.github.owner}/${accounts.github.repository}`,
+        },
+        email: {
+            personaId,
+            organizationId,
+            inboxAddress: accounts.email.inboxAddress,
+        },
+        genericRest: {
+            personaId,
+            organizationId,
+            tenantId: accounts.genericRest.tenantId,
+        },
+    };
 }
 function normalizeLineage(value) {
     const lineage = readObject(value, "Synthetic world lineage is invalid.");
     assertExactKeys(lineage, ["parentId", "parentRevision"], "Synthetic world lineage");
-    if (!Number.isInteger(lineage.parentRevision) || lineage.parentRevision < 0)
+    if (!Number.isInteger(lineage.parentRevision) ||
+        lineage.parentRevision < 0)
         throw new SyntheticWorldError("Synthetic world lineage revision is invalid.");
-    return { parentId: normalizeIdentifier(lineage.parentId, "Synthetic world parent id"), parentRevision: lineage.parentRevision };
+    return {
+        parentId: normalizeIdentifier(lineage.parentId, "Synthetic world parent id"),
+        parentRevision: lineage.parentRevision,
+    };
 }
 function normalizeState(value, manifest) {
     const state = readObject(value, "Synthetic world state is invalid.");
@@ -335,9 +533,19 @@ function normalizeState(value, manifest) {
     const messages = normalizeMessages(email.messages, subscriptions, manifest);
     const failures = normalizeFailures(genericRest.failures, subscriptions, manifest);
     const receipts = normalizeReceipts(state.receipts, customers, subscriptions, messages, issues, failures, manifest);
-    if (customers.length !== subscriptions.length || customers.length !== issues.length || customers.length !== messages.length || customers.length !== failures.length || customers.length !== receipts.length)
+    if (customers.length !== subscriptions.length ||
+        customers.length !== issues.length ||
+        customers.length !== messages.length ||
+        customers.length !== failures.length ||
+        customers.length !== receipts.length)
         throw new SyntheticWorldError("Synthetic world providers have inconsistent workflow state.");
-    if (new Set(customers.map((customer) => customer.id)).size !== customers.length || new Set(subscriptions.map((subscription) => subscription.id)).size !== subscriptions.length || new Set(messages.map((message) => message.id)).size !== messages.length || new Set(issues.map((issue) => issue.number)).size !== issues.length || new Set(failures.map((failure) => failure.id)).size !== failures.length) {
+    if (new Set(customers.map((customer) => customer.id)).size !==
+        customers.length ||
+        new Set(subscriptions.map((subscription) => subscription.id)).size !==
+            subscriptions.length ||
+        new Set(messages.map((message) => message.id)).size !== messages.length ||
+        new Set(issues.map((issue) => issue.number)).size !== issues.length ||
+        new Set(failures.map((failure) => failure.id)).size !== failures.length) {
         throw new SyntheticWorldError("Synthetic world contains duplicate provider resources.");
     }
     const subscriptionsById = new Map(subscriptions.map((subscription) => [subscription.id, subscription]));
@@ -346,19 +554,37 @@ function normalizeState(value, manifest) {
     const failuresById = new Map(failures.map((failure) => [failure.id, failure]));
     for (const receipt of receipts) {
         const subscription = subscriptionsById.get(receipt.subscriptionId);
-        if (subscription?.customerId !== receipt.customerId || messagesById.get(receipt.emailId)?.relatedSubscriptionId !== receipt.subscriptionId || issuesByNumber.get(receipt.issueNumber)?.relatedSubscriptionId !== receipt.subscriptionId || failuresById.get(receipt.genericFailureId)?.relatedSubscriptionId !== receipt.subscriptionId) {
+        if (subscription?.customerId !== receipt.customerId ||
+            messagesById.get(receipt.emailId)?.relatedSubscriptionId !==
+                receipt.subscriptionId ||
+            issuesByNumber.get(receipt.issueNumber)?.relatedSubscriptionId !==
+                receipt.subscriptionId ||
+            failuresById.get(receipt.genericFailureId)?.relatedSubscriptionId !==
+                receipt.subscriptionId) {
             throw new SyntheticWorldError("Synthetic workflow receipt does not link one consistent cross-provider transition.");
         }
     }
-    return { clockAt: state.clockAt, stripe: { customers, subscriptions }, github: { issues }, email: { messages }, genericRest: { failures }, receipts };
+    return {
+        clockAt: state.clockAt,
+        stripe: { customers, subscriptions },
+        github: { issues },
+        email: { messages },
+        genericRest: { failures },
+        receipts,
+    };
 }
 function normalizeCustomers(value, manifest) {
     return readArray(value, "Synthetic Stripe customers", MAX_WORKFLOW_RECEIPTS).map((entry) => {
         const customer = readObject(entry, "Synthetic Stripe customer is invalid.");
         assertExactKeys(customer, ["id", "personaId", "organizationId"], "Synthetic Stripe customer");
-        if (customer.personaId !== manifest.personas[0].id || customer.organizationId !== manifest.organizations[0].id)
+        if (customer.personaId !== manifest.personas[0].id ||
+            customer.organizationId !== manifest.organizations[0].id)
             throw new SyntheticWorldError("Synthetic Stripe customer identity is inconsistent.");
-        return { id: normalizeIdentifier(customer.id, "Synthetic Stripe customer id"), personaId: manifest.personas[0].id, organizationId: manifest.organizations[0].id };
+        return {
+            id: normalizeIdentifier(customer.id, "Synthetic Stripe customer id"),
+            personaId: manifest.personas[0].id,
+            organizationId: manifest.organizations[0].id,
+        };
     });
 }
 function normalizeSubscriptions(value, customers, manifest) {
@@ -366,9 +592,18 @@ function normalizeSubscriptions(value, customers, manifest) {
     return readArray(value, "Synthetic Stripe subscriptions", MAX_WORKFLOW_RECEIPTS).map((entry) => {
         const subscription = readObject(entry, "Synthetic Stripe subscription is invalid.");
         assertExactKeys(subscription, ["id", "customerId", "priceId", "status", "failureCode"], "Synthetic Stripe subscription");
-        if (!customerIds.has(subscription.customerId) || subscription.priceId !== manifest.resources.defaultPriceId || subscription.status !== "past_due" || subscription.failureCode !== "card_declined")
+        if (!customerIds.has(subscription.customerId) ||
+            subscription.priceId !== manifest.resources.defaultPriceId ||
+            subscription.status !== "past_due" ||
+            subscription.failureCode !== "card_declined")
             throw new SyntheticWorldError("Synthetic Stripe subscription is inconsistent.");
-        return { id: normalizeIdentifier(subscription.id, "Synthetic Stripe subscription id"), customerId: subscription.customerId, priceId: manifest.resources.defaultPriceId, status: "past_due", failureCode: "card_declined" };
+        return {
+            id: normalizeIdentifier(subscription.id, "Synthetic Stripe subscription id"),
+            customerId: subscription.customerId,
+            priceId: manifest.resources.defaultPriceId,
+            status: "past_due",
+            failureCode: "card_declined",
+        };
     });
 }
 function normalizeIssues(value, subscriptions, manifest) {
@@ -376,9 +611,20 @@ function normalizeIssues(value, subscriptions, manifest) {
     return readArray(value, "Synthetic GitHub issues", MAX_WORKFLOW_RECEIPTS).map((entry) => {
         const issue = readObject(entry, "Synthetic GitHub issue is invalid.");
         assertExactKeys(issue, ["number", "repository", "title", "status", "relatedSubscriptionId"], "Synthetic GitHub issue");
-        if (!Number.isInteger(issue.number) || issue.number < 1 || issue.repository !== manifest.providerProjections.github.repository || typeof issue.title !== "string" || issue.status !== "open" || !subscriptionsById.has(issue.relatedSubscriptionId))
+        if (!Number.isInteger(issue.number) ||
+            issue.number < 1 ||
+            issue.repository !== manifest.providerProjections.github.repository ||
+            typeof issue.title !== "string" ||
+            issue.status !== "open" ||
+            !subscriptionsById.has(issue.relatedSubscriptionId))
             throw new SyntheticWorldError("Synthetic GitHub issue is inconsistent.");
-        return { number: issue.number, repository: manifest.providerProjections.github.repository, title: normalizeSafeText(issue.title, "Synthetic GitHub issue title", 160), status: "open", relatedSubscriptionId: issue.relatedSubscriptionId };
+        return {
+            number: issue.number,
+            repository: manifest.providerProjections.github.repository,
+            title: normalizeSafeText(issue.title, "Synthetic GitHub issue title", 160),
+            status: "open",
+            relatedSubscriptionId: issue.relatedSubscriptionId,
+        };
     });
 }
 function normalizeMessages(value, subscriptions, manifest) {
@@ -386,9 +632,16 @@ function normalizeMessages(value, subscriptions, manifest) {
     return readArray(value, "Synthetic email messages", MAX_WORKFLOW_RECEIPTS).map((entry) => {
         const message = readObject(entry, "Synthetic email message is invalid.");
         assertExactKeys(message, ["id", "to", "template", "relatedSubscriptionId"], "Synthetic email message");
-        if (message.to !== manifest.accounts.email.inboxAddress || message.template !== "subscription-payment-failed" || !subscriptionsById.has(message.relatedSubscriptionId))
+        if (message.to !== manifest.accounts.email.inboxAddress ||
+            message.template !== "subscription-payment-failed" ||
+            !subscriptionsById.has(message.relatedSubscriptionId))
             throw new SyntheticWorldError("Synthetic email message is inconsistent.");
-        return { id: normalizeIdentifier(message.id, "Synthetic email message id"), to: manifest.accounts.email.inboxAddress, template: "subscription-payment-failed", relatedSubscriptionId: message.relatedSubscriptionId };
+        return {
+            id: normalizeIdentifier(message.id, "Synthetic email message id"),
+            to: manifest.accounts.email.inboxAddress,
+            template: "subscription-payment-failed",
+            relatedSubscriptionId: message.relatedSubscriptionId,
+        };
     });
 }
 function normalizeFailures(value, subscriptions, manifest) {
@@ -396,9 +649,16 @@ function normalizeFailures(value, subscriptions, manifest) {
     return readArray(value, "Synthetic generic REST failures", MAX_WORKFLOW_RECEIPTS).map((entry) => {
         const failure = readObject(entry, "Synthetic generic REST failure is invalid.");
         assertExactKeys(failure, ["id", "tenantId", "code", "relatedSubscriptionId"], "Synthetic generic REST failure");
-        if (failure.tenantId !== manifest.accounts.genericRest.tenantId || failure.code !== "payment_failed" || !subscriptionsById.has(failure.relatedSubscriptionId))
+        if (failure.tenantId !== manifest.accounts.genericRest.tenantId ||
+            failure.code !== "payment_failed" ||
+            !subscriptionsById.has(failure.relatedSubscriptionId))
             throw new SyntheticWorldError("Synthetic generic REST failure is inconsistent.");
-        return { id: normalizeIdentifier(failure.id, "Synthetic generic REST failure id"), tenantId: manifest.accounts.genericRest.tenantId, code: "payment_failed", relatedSubscriptionId: failure.relatedSubscriptionId };
+        return {
+            id: normalizeIdentifier(failure.id, "Synthetic generic REST failure id"),
+            tenantId: manifest.accounts.genericRest.tenantId,
+            code: "payment_failed",
+            relatedSubscriptionId: failure.relatedSubscriptionId,
+        };
     });
 }
 function normalizeReceipts(value, customers, subscriptions, messages, issues, failures, manifest) {
@@ -410,21 +670,51 @@ function normalizeReceipts(value, customers, subscriptions, messages, issues, fa
     const actionIds = new Set();
     return readArray(value, "Synthetic workflow receipts", MAX_WORKFLOW_RECEIPTS).map((entry) => {
         const receipt = readObject(entry, "Synthetic workflow receipt is invalid.");
-        assertExactKeys(receipt, ["actionId", "customerId", "subscriptionId", "emailId", "issueNumber", "genericFailureId", "completedAt"], "Synthetic workflow receipt");
+        assertExactKeys(receipt, [
+            "actionId",
+            "customerId",
+            "subscriptionId",
+            "emailId",
+            "issueNumber",
+            "genericFailureId",
+            "completedAt",
+        ], "Synthetic workflow receipt");
         const actionId = normalizeIdentifier(receipt.actionId, "Synthetic workflow action id");
-        if (actionIds.has(actionId) || !customerIds.has(receipt.customerId) || !subscriptionIds.has(receipt.subscriptionId) || !messageIds.has(receipt.emailId) || !issueNumbers.has(receipt.issueNumber) || !failureIds.has(receipt.genericFailureId) || !isTimestamp(receipt.completedAt) || receipt.completedAt < manifest.clock.initialAt)
+        if (actionIds.has(actionId) ||
+            !customerIds.has(receipt.customerId) ||
+            !subscriptionIds.has(receipt.subscriptionId) ||
+            !messageIds.has(receipt.emailId) ||
+            !issueNumbers.has(receipt.issueNumber) ||
+            !failureIds.has(receipt.genericFailureId) ||
+            !isTimestamp(receipt.completedAt) ||
+            receipt.completedAt < manifest.clock.initialAt)
             throw new SyntheticWorldError("Synthetic workflow receipt is inconsistent.");
         actionIds.add(actionId);
-        return { actionId, customerId: receipt.customerId, subscriptionId: receipt.subscriptionId, emailId: receipt.emailId, issueNumber: receipt.issueNumber, genericFailureId: receipt.genericFailureId, completedAt: receipt.completedAt };
+        return {
+            actionId,
+            customerId: receipt.customerId,
+            subscriptionId: receipt.subscriptionId,
+            emailId: receipt.emailId,
+            issueNumber: receipt.issueNumber,
+            genericFailureId: receipt.genericFailureId,
+            completedAt: receipt.completedAt,
+        };
     });
 }
 function normalizeIdentifier(value, label) {
-    if (typeof value !== "string" || !IDENTIFIER.test(value) || sanitizeSecretString(value) !== value)
+    if (typeof value !== "string" ||
+        !IDENTIFIER.test(value) ||
+        sanitizeSecretString(value) !== value)
         throw new SyntheticWorldError(`${label} must be a safe stable identifier.`);
     return value;
 }
 function normalizeSeed(value) {
-    if (typeof value !== "string" || value.trim() === "" || value.length > MAX_SEED_LENGTH || /[\r\n\t]/.test(value) || sanitizeSecretString(value) !== value || hasObviousPii(value))
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.length > MAX_SEED_LENGTH ||
+        /[\r\n\t]/.test(value) ||
+        sanitizeSecretString(value) !== value ||
+        hasObviousPii(value))
         throw new SyntheticWorldError("World seed must be a non-secret, non-PII 1-128 character string.");
     return value;
 }
@@ -432,7 +722,12 @@ function normalizeTitle(value) {
     return normalizeSafeText(value, "World title", 120);
 }
 function normalizeSafeText(value, label, maximumLength) {
-    if (typeof value !== "string" || value.trim() === "" || value.trim().length > maximumLength || /[\r\n\t]/.test(value) || sanitizeSecretString(value) !== value || hasObviousPii(value))
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.trim().length > maximumLength ||
+        /[\r\n\t]/.test(value) ||
+        sanitizeSecretString(value) !== value ||
+        hasObviousPii(value))
         throw new SyntheticWorldError(`${label} must be safe non-PII plain text.`);
     return value.trim();
 }
@@ -442,7 +737,8 @@ function normalizeBasePath(value) {
     return value;
 }
 function normalizeSyntheticInboxAddress(value) {
-    if (typeof value !== "string" || !/^operator-[a-f0-9]{12}@ghostapi\.invalid$/.test(value))
+    if (typeof value !== "string" ||
+        !/^operator-[a-f0-9]{12}@ghostapi\.invalid$/.test(value))
         throw new SyntheticWorldError("Synthetic inbox address must use the generated ghostapi.invalid format.");
     return value;
 }
@@ -480,10 +776,13 @@ function nextTimestamp(value) {
     return new Date(Date.parse(value) + 1000).toISOString();
 }
 function isTimestamp(value) {
-    return typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) && Number.isFinite(Date.parse(value));
+    return (typeof value === "string" &&
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) &&
+        Number.isFinite(Date.parse(value)));
 }
 function hasObviousPii(value) {
-    return /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(value) || /(?:\+\d[\d(). -]{7,}\d|\b\d{3}[ .-]\d{3}[ .-]\d{4}\b)/.test(value);
+    return (/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(value) ||
+        /(?:\+\d[\d(). -]{7,}\d|\b\d{3}[ .-]\d{3}[ .-]\d{4}\b)/.test(value));
 }
 function isErrorCode(error, code) {
     return error instanceof Error && "code" in error && error.code === code;