@loremcorp/scenarios 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LoremCorp contributors
+
+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/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./launch.js";
+export * from "./scenario.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./launch.js";
+export * from "./scenario.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/launch.d.ts

@@ -0,0 +1,175 @@
+export declare const pricingMigrationScenario: {
+    id: string;
+    company: "halcyon";
+    duration: "5 sim-days";
+    pathology: string;
+    mocks: ("mock-slacker" | "mock-zendisk" | "mock-salesfarce" | "mock-strype" | "mock-gothub" | "mock-notian" | "mock-halpcenter")[];
+    heroPersonaIds: string[];
+    timeline: {
+        id: string;
+        at: string;
+        source: import("@loremcorp/engine").MockSurface;
+        type: string;
+        entityId: string;
+        payload: Record<string, string | number | boolean>;
+        apply: ((context: import("./types.js").ScenarioContext, event: import("@loremcorp/engine").LoremEvent) => void | Promise<void>) | undefined;
+        causedBy: readonly string[] | undefined;
+    }[];
+    assertions: {
+        id: string;
+        at: string;
+        description: string;
+        check: (events: readonly import("@loremcorp/engine").LoremEvent[], context: import("./types.js").ScenarioContext) => boolean;
+    }[];
+    rubric: {
+        triage_speed: number;
+        customer_communication: number;
+        technical_resolution: number;
+        business_impact_mitigated: number;
+    };
+};
+export declare const plaidOutageScenario: {
+    id: string;
+    company: "halcyon";
+    duration: "24 sim-hours";
+    pathology: string;
+    mocks: ("mock-slacker" | "mock-zendisk" | "mock-strype" | "mock-notian" | "mock-halpcenter")[];
+    heroPersonaIds: string[];
+    timeline: {
+        id: string;
+        at: string;
+        source: import("@loremcorp/engine").MockSurface;
+        type: string;
+        entityId: string;
+        payload: Record<string, string | number | boolean>;
+        apply: ((context: import("./types.js").ScenarioContext, event: import("@loremcorp/engine").LoremEvent) => void | Promise<void>) | undefined;
+        causedBy: readonly string[] | undefined;
+    }[];
+    assertions: {
+        id: string;
+        at: string;
+        description: string;
+        check: (events: readonly import("@loremcorp/engine").LoremEvent[], context: import("./types.js").ScenarioContext) => boolean;
+    }[];
+    rubric: {
+        detection_speed: number;
+        comms_cadence: number;
+        resolution_time: number;
+        comms_quality: number;
+    };
+};
+export declare const quietWeekScenario: {
+    id: string;
+    company: "halcyon";
+    duration: "7 sim-days";
+    pathology: string;
+    mocks: ("mock-slacker" | "mock-zendisk" | "mock-salesfarce" | "mock-strype" | "mock-gothub" | "mock-notian" | "mock-halpcenter")[];
+    heroPersonaIds: string[];
+    timeline: {
+        id: string;
+        at: string;
+        source: import("@loremcorp/engine").MockSurface;
+        type: string;
+        entityId: string;
+        payload: Record<string, string | number | boolean>;
+        apply: ((context: import("./types.js").ScenarioContext, event: import("@loremcorp/engine").LoremEvent) => void | Promise<void>) | undefined;
+        causedBy: readonly string[] | undefined;
+    }[];
+    assertions: {
+        id: string;
+        at: string;
+        description: string;
+        check: (events: readonly import("@loremcorp/engine").LoremEvent[], context: import("./types.js").ScenarioContext) => boolean;
+    }[];
+    rubric: {
+        baseline_behavior_consistency: number;
+        no_false_positive_escalations: number;
+    };
+};
+export declare const launchScenarios: readonly [{
+    id: string;
+    company: "halcyon";
+    duration: "5 sim-days";
+    pathology: string;
+    mocks: ("mock-slacker" | "mock-zendisk" | "mock-salesfarce" | "mock-strype" | "mock-gothub" | "mock-notian" | "mock-halpcenter")[];
+    heroPersonaIds: string[];
+    timeline: {
+        id: string;
+        at: string;
+        source: import("@loremcorp/engine").MockSurface;
+        type: string;
+        entityId: string;
+        payload: Record<string, string | number | boolean>;
+        apply: ((context: import("./types.js").ScenarioContext, event: import("@loremcorp/engine").LoremEvent) => void | Promise<void>) | undefined;
+        causedBy: readonly string[] | undefined;
+    }[];
+    assertions: {
+        id: string;
+        at: string;
+        description: string;
+        check: (events: readonly import("@loremcorp/engine").LoremEvent[], context: import("./types.js").ScenarioContext) => boolean;
+    }[];
+    rubric: {
+        triage_speed: number;
+        customer_communication: number;
+        technical_resolution: number;
+        business_impact_mitigated: number;
+    };
+}, {
+    id: string;
+    company: "halcyon";
+    duration: "24 sim-hours";
+    pathology: string;
+    mocks: ("mock-slacker" | "mock-zendisk" | "mock-strype" | "mock-notian" | "mock-halpcenter")[];
+    heroPersonaIds: string[];
+    timeline: {
+        id: string;
+        at: string;
+        source: import("@loremcorp/engine").MockSurface;
+        type: string;
+        entityId: string;
+        payload: Record<string, string | number | boolean>;
+        apply: ((context: import("./types.js").ScenarioContext, event: import("@loremcorp/engine").LoremEvent) => void | Promise<void>) | undefined;
+        causedBy: readonly string[] | undefined;
+    }[];
+    assertions: {
+        id: string;
+        at: string;
+        description: string;
+        check: (events: readonly import("@loremcorp/engine").LoremEvent[], context: import("./types.js").ScenarioContext) => boolean;
+    }[];
+    rubric: {
+        detection_speed: number;
+        comms_cadence: number;
+        resolution_time: number;
+        comms_quality: number;
+    };
+}, {
+    id: string;
+    company: "halcyon";
+    duration: "7 sim-days";
+    pathology: string;
+    mocks: ("mock-slacker" | "mock-zendisk" | "mock-salesfarce" | "mock-strype" | "mock-gothub" | "mock-notian" | "mock-halpcenter")[];
+    heroPersonaIds: string[];
+    timeline: {
+        id: string;
+        at: string;
+        source: import("@loremcorp/engine").MockSurface;
+        type: string;
+        entityId: string;
+        payload: Record<string, string | number | boolean>;
+        apply: ((context: import("./types.js").ScenarioContext, event: import("@loremcorp/engine").LoremEvent) => void | Promise<void>) | undefined;
+        causedBy: readonly string[] | undefined;
+    }[];
+    assertions: {
+        id: string;
+        at: string;
+        description: string;
+        check: (events: readonly import("@loremcorp/engine").LoremEvent[], context: import("./types.js").ScenarioContext) => boolean;
+    }[];
+    rubric: {
+        baseline_behavior_consistency: number;
+        no_false_positive_escalations: number;
+    };
+}];
+//# sourceMappingURL=launch.d.ts.map

package/dist/launch.js

@@ -0,0 +1,112 @@
+import { scenario } from "./scenario.js";
+export const pricingMigrationScenario = scenario({
+    id: "pricing-migration",
+    company: "halcyon",
+    duration: "5 sim-days",
+    pathology: "billing-error-cascade",
+    mocks: ["mock-slacker", "mock-zendisk", "mock-salesfarce", "mock-strype", "mock-gothub", "mock-notian", "mock-halpcenter"],
+    heroPersonaIds: ["maya-okafor", "ben-reyes", "diego-soto", "priya-iyer", "samira-khan", "marcus-thorne", "alex-vega", "pat-donovan"],
+    timeline: [
+        step("misapplied-upgrade", "T+0", "mock-strype", "strype.misapplied_upgrade", "ent_halcyon_alex_vega", { affected_count: 12000, old_price: 999, new_price: 1499 }, ({ runtime }) => {
+            runtime.state.strype.events.push({ id: "evt_pricing_migration", type: "misapplied_upgrade", affected_count: 12000 });
+        }),
+        step("diego-posts", "T+10m", "mock-slacker", "slacker.message.posted", "ent_halcyon_diego_soto", { channel: "C-customer-trust", user: "diego-soto", text: "I need final refund policy before this becomes a public update." }, ({ runtime }) => {
+            runtime.state.slacker.messages.push({ ts: "scenario.pricing.1", channel: "C-customer-trust", user: "diego-soto", text: "I need final refund policy before this becomes a public update.", entity_id: "ent_halcyon_diego_soto" });
+        }),
+        step("ticket-spike", "T+30m", "mock-zendisk", "zendisk.ticket_spike.detected", "ent_halcyon_priya_iyer", { multiplier: 8, tag: "pricing-migration" }, ({ runtime }) => {
+            runtime.state.zendisk.tickets.push({
+                id: 9001,
+                subject: "I was charged the new price even though I was grandfathered",
+                description: "My account was promised old pricing.",
+                status: "new",
+                priority: "urgent",
+                requester_id: "pat-donovan",
+                entity_id: "ent_halcyon_pat_donovan",
+                tags: ["pricing-migration", "grandfathered"],
+                created_at: runtime.now().iso,
+                updated_at: runtime.now().iso
+            });
+        }),
+        step("alex-video", "T+2h", "company", "external.youtube_video.published", "ent_halcyon_alex_vega", { title: "Halcyon Just Pulled a Mint", subscribers: 800000 }, undefined, ["misapplied-upgrade"]),
+        step("halpcenter-draft", "T+4h", "mock-halpcenter", "halpcenter.article.created", "ent_halcyon_diego_soto", { title: "Pricing migration refund FAQ", status: "draft" }, ({ runtime }) => {
+            runtime.state.halpcenter.articles.push({ id: 9001, title: "Pricing migration refund FAQ", body: "Draft refund and grandfathering guidance.", status: "draft", entity_id: "ent_halcyon_diego_soto", updated_at: runtime.now().iso });
+        }, ["diego-posts"]),
+        step("deal-risk", "T+24h", "mock-salesfarce", "salesfarce.opportunity.risk_flagged", "ent_account_brooklyn_advisors", { opportunity_id: "006-advisors-pilot", risk: "High", reason: "pricing trust incident" }, undefined, ["alex-video"]),
+        step("refund-batch", "T+36h", "mock-strype", "strype.refund_batch.created", "ent_halcyon_pat_donovan", { count: 12000, status: "processing" }, ({ runtime }) => {
+            runtime.state.strype.refunds.push({ id: "re_batch_pricing_migration", count: 12000, status: "processing", entity_id: "ent_halcyon_pat_donovan" });
+        }, ["ticket-spike"])
+    ],
+    assertions: [
+        assertion("all_affected_users_acknowledged", "T+1h", "A Zendisk spike is detected and tagged for affected grandfathered users.", (events) => events.some((event) => event.type === "zendisk.ticket_spike.detected")),
+        assertion("refund_queue_processed_under_sla", "T+48h", "A Strype refund batch exists before the 48-hour SLA.", (events) => events.some((event) => event.type === "strype.refund_batch.created")),
+        assertion("public_help_article_started", "T+6h", "A Halpcenter draft exists before external comms harden.", (events) => events.some((event) => event.type === "halpcenter.article.created"))
+    ],
+    rubric: {
+        triage_speed: 0.3,
+        customer_communication: 0.3,
+        technical_resolution: 0.2,
+        business_impact_mitigated: 0.2
+    }
+});
+export const plaidOutageScenario = scenario({
+    id: "plaid-outage",
+    company: "halcyon",
+    duration: "24 sim-hours",
+    pathology: "infrastructure-dependency-failure",
+    mocks: ["mock-slacker", "mock-zendisk", "mock-halpcenter", "mock-strype", "mock-notian"],
+    heroPersonaIds: ["marcus-thorne", "priya-iyer", "jamie-park", "maya-okafor", "pat-donovan"],
+    timeline: [
+        step("sync-alert", "T+0", "mock-gothub", "gothub.alert.referenced", "ent_repo_halcyon_app", { dependency: "Plaid", bank: "Bank of America", affected_percent: 30 }),
+        step("oncall-thread", "T+10m", "mock-slacker", "slacker.thread.started", "ent_halcyon_marcus_thorne", { channel: "C-eng-incidents", user: "marcus-thorne", text: "BofA sync failures confirmed. Triage owner is Data Platform." }, undefined, ["sync-alert"]),
+        step("support-tickets", "T+35m", "mock-zendisk", "zendisk.ticket_spike.detected", "ent_halcyon_jamie_park", { tag: "bofa-sync", multiplier: 4 }, undefined, ["sync-alert"]),
+        step("status-article", "T+1h", "mock-halpcenter", "halpcenter.article.updated", "ent_halcyon_jamie_park", { article_id: 2001, title: "Reconnect a bank account", status: "published" }, undefined, ["support-tickets"]),
+        step("postmortem", "T+20h", "mock-notian", "notian.page.updated", "ent_halcyon_marcus_thorne", { page_id: "notian_bofa_postmortem", status: "updated" }, undefined, ["oncall-thread"])
+    ],
+    assertions: [
+        assertion("oncall_rotation_pickup", "T+15m", "On-call thread starts quickly.", (events) => events.some((event) => event.type === "slacker.thread.started")),
+        assertion("status_page_update_timing", "T+2h", "Customer-facing help article is updated.", (events) => events.some((event) => event.type === "halpcenter.article.updated")),
+        assertion("postmortem_captured", "T+24h", "Incident residue lands in Notian.", (events) => events.some((event) => event.type === "notian.page.updated"))
+    ],
+    rubric: {
+        detection_speed: 0.25,
+        comms_cadence: 0.25,
+        resolution_time: 0.25,
+        comms_quality: 0.25
+    }
+});
+export const quietWeekScenario = scenario({
+    id: "quiet-week",
+    company: "halcyon",
+    duration: "7 sim-days",
+    pathology: "baseline-normal-operations",
+    mocks: ["mock-slacker", "mock-zendisk", "mock-salesfarce", "mock-strype", "mock-gothub", "mock-notian", "mock-halpcenter"],
+    heroPersonaIds: ["maya-okafor", "ben-reyes", "priya-iyer", "marcus-thorne", "jamie-park", "samira-khan", "diego-soto", "carla-mendez"],
+    timeline: [
+        step("normal-ticket", "T+2h", "mock-zendisk", "zendisk.ticket.created", "ent_halcyon_olivia_martens", { subject: "Question about export categories", priority: "normal" }),
+        step("normal-slack", "T+6h", "mock-slacker", "slacker.message.posted", "ent_halcyon_nora_baldwin", { channel: "C-general", user: "nora-baldwin", text: "Roadmap review notes are in Notian." }),
+        step("normal-renewal", "T+12h", "mock-strype", "strype.subscription.renewed", "ent_halcyon_pat_donovan", { subscription_id: "sub_pat_donovan", amount: 999 }),
+        step("normal-pr", "T+1d", "mock-gothub", "gothub.pull_request.merged", "ent_halcyon_levi_kapoor", { repo: "halcyon/app", number: 43 }),
+        step("normal-doc", "T+2d", "mock-notian", "notian.page.updated", "ent_halcyon_marcus_thorne", { page_id: "weekly-all-hands", title: "Weekly all-hands recap" }),
+        step("normal-article", "T+4d", "mock-halpcenter", "halpcenter.article.updated", "ent_halcyon_diego_soto", { article_id: 2002, title: "How Halcyon pricing works" }),
+        step("normal-sales", "T+5d", "mock-salesfarce", "salesfarce.activity.created", "ent_account_brooklyn_advisors", { subject: "Advisor pilot follow-up", owner: "harper-singh" })
+    ],
+    assertions: [
+        assertion("all_mocks_hummed", "T+7d", "Every MVP mock emits at least one normal event.", (events) => {
+            const sources = new Set(events.filter((event) => event.source.startsWith("mock-")).map((event) => event.source));
+            return sources.size === 7;
+        }),
+        assertion("no_crisis_injected", "T+7d", "Quiet week avoids crisis event types.", (events) => !events.some((event) => event.type.includes("spike") || event.type.includes("misapplied")))
+    ],
+    rubric: {
+        baseline_behavior_consistency: 0.5,
+        no_false_positive_escalations: 0.5
+    }
+});
+export const launchScenarios = [pricingMigrationScenario, plaidOutageScenario, quietWeekScenario];
+function step(id, at, source, type, entityId, payload, apply, causedBy) {
+    return { id, at, source, type, entityId, payload, apply, causedBy };
+}
+function assertion(id, at, description, check) {
+    return { id, at, description, check };
+}
+//# sourceMappingURL=launch.js.map

package/dist/scenario.d.ts

@@ -0,0 +1,12 @@
+import { type EventBus } from "@loremcorp/engine";
+import type { MockRuntimeContext } from "@loremcorp/mocks-shared";
+import type { ScenarioDefinition, ScenarioRunResult } from "./types.js";
+export declare function scenario<TDefinition extends ScenarioDefinition>(definition: TDefinition): TDefinition;
+export interface RunScenarioOptions {
+    readonly scenario: ScenarioDefinition;
+    readonly runtime: MockRuntimeContext;
+    readonly bus: EventBus;
+    readonly startAt?: string;
+}
+export declare function runScenario(options: RunScenarioOptions): Promise<ScenarioRunResult>;
+//# sourceMappingURL=scenario.d.ts.map

package/dist/scenario.js

@@ -0,0 +1,107 @@
+import { simTimestamp } from "@loremcorp/engine";
+export function scenario(definition) {
+    return definition;
+}
+export async function runScenario(options) {
+    const startAt = simTimestamp(options.startAt ?? options.runtime.now().iso);
+    const emitted = new Map();
+    const context = {
+        runtime: options.runtime,
+        bus: options.bus,
+        emitted
+    };
+    const started = await options.bus.emit({
+        forkId: options.runtime.forkId,
+        source: "engine",
+        type: "scenario.started",
+        origin: "scenario",
+        simTime: startAt,
+        payload: {
+            scenario_id: options.scenario.id,
+            company: options.scenario.company,
+            pathology: options.scenario.pathology
+        }
+    });
+    emitted.set("scenario.started", started);
+    for (const step of options.scenario.timeline) {
+        if (isBranchStep(step)) {
+            const branchEvent = await options.bus.emit({
+                forkId: options.runtime.forkId,
+                source: "engine",
+                type: "scenario.branch.evaluated",
+                origin: "scenario",
+                simTime: addOffset(startAt.iso, step.at),
+                causedBy: [started.id],
+                payload: {
+                    step_id: step.id,
+                    condition: step.branch.if,
+                    selected: step.branch.else
+                }
+            });
+            emitted.set(step.id, branchEvent);
+            continue;
+        }
+        const event = await emitScenarioStep(step, options.runtime, options.bus, startAt.iso, emitted, started);
+        emitted.set(step.id, event);
+        await step.apply?.(context, event);
+    }
+    const events = Array.from(emitted.values());
+    const assertions = options.scenario.assertions.map((assertion) => ({
+        id: assertion.id,
+        passed: assertion.check(events, context),
+        description: assertion.description
+    }));
+    await options.bus.emit({
+        forkId: options.runtime.forkId,
+        source: "engine",
+        type: "scenario.completed",
+        origin: "scenario",
+        simTime: addOffset(startAt.iso, options.scenario.duration.replace("sim-", "sim-")),
+        causedBy: [started.id],
+        payload: {
+            scenario_id: options.scenario.id,
+            assertions_passed: assertions.filter((assertion) => assertion.passed).length,
+            assertions_total: assertions.length
+        }
+    });
+    return {
+        scenarioId: options.scenario.id,
+        eventIds: events.map((event) => event.id),
+        assertions
+    };
+}
+function isBranchStep(step) {
+    return "branch" in step;
+}
+async function emitScenarioStep(step, runtime, bus, startAt, emitted, started) {
+    const causedBy = step.causedBy?.map((stepId) => emitted.get(stepId)?.id).filter((id) => Boolean(id));
+    return bus.emit({
+        forkId: runtime.forkId,
+        source: step.source,
+        type: step.type,
+        origin: "scenario",
+        simTime: addOffset(startAt, step.at),
+        entityId: step.entityId,
+        personaId: step.personaId,
+        causedBy: causedBy && causedBy.length > 0 ? causedBy : [started.id],
+        payload: step.payload
+    });
+}
+function addOffset(startAt, offset) {
+    const start = simTimestamp(startAt).epochMs;
+    if (offset === "T+0")
+        return simTimestamp(start);
+    const match = /^T\+(\d+)(m|h|d)$/.exec(offset);
+    if (!match) {
+        const durationMatch = /^(\d+) sim-(hours|days)$/.exec(offset);
+        if (!durationMatch)
+            return simTimestamp(start);
+        const amount = Number(durationMatch[1]);
+        return simTimestamp(start + amount * (durationMatch[2] === "days" ? 24 * 60 * 60 * 1000 : 60 * 60 * 1000));
+    }
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const multiplier = unit === "d" ? 24 * 60 * 60 * 1000 : unit === "h" ? 60 * 60 * 1000 : 60 * 1000;
+    return simTimestamp(start + amount * multiplier);
+}
+//# sourceMappingURL=scenario.js.map

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+import type { EventBus, EventId, JsonObject, LoremEvent, MockSurface } from "@loremcorp/engine";
+import type { MockRuntimeContext } from "@loremcorp/mocks-shared";
+export type ScenarioDuration = `${number} sim-days` | `${number} sim-hours`;
+export interface ScenarioContext {
+    readonly runtime: MockRuntimeContext;
+    readonly bus: EventBus;
+    readonly emitted: ReadonlyMap<string, LoremEvent>;
+}
+export interface ScenarioEventStep {
+    readonly id: string;
+    readonly at: string;
+    readonly source: MockSurface;
+    readonly type: string;
+    readonly entityId?: string;
+    readonly personaId?: string;
+    readonly payload: JsonObject;
+    readonly causedBy?: readonly string[];
+    apply?(context: ScenarioContext, event: LoremEvent): void | Promise<void>;
+}
+export interface ScenarioBranchStep {
+    readonly id: string;
+    readonly at: string;
+    readonly branch: {
+        readonly if: string;
+        readonly then: string;
+        readonly else: string;
+    };
+}
+export type ScenarioTimelineStep = ScenarioEventStep | ScenarioBranchStep;
+export interface ScenarioAssertion {
+    readonly id: string;
+    readonly at: string;
+    readonly description: string;
+    check(events: readonly LoremEvent[], context: ScenarioContext): boolean;
+}
+export interface ScenarioDefinition {
+    readonly id: string;
+    readonly company: "halcyon";
+    readonly duration: ScenarioDuration;
+    readonly pathology: string;
+    readonly mocks: readonly MockSurface[];
+    readonly heroPersonaIds: readonly string[];
+    readonly timeline: readonly ScenarioTimelineStep[];
+    readonly assertions: readonly ScenarioAssertion[];
+    readonly rubric: Readonly<Record<string, number>>;
+}
+export interface AssertionResult {
+    readonly id: string;
+    readonly passed: boolean;
+    readonly description: string;
+}
+export interface ScenarioRunResult {
+    readonly scenarioId: string;
+    readonly eventIds: readonly EventId[];
+    readonly assertions: readonly AssertionResult[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@loremcorp/scenarios",
+  "version": "0.1.0",
+  "description": "Scenario definitions and executor for LoremCorp synthetic companies.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielthedm/loremcorp.git",
+    "directory": "packages/scenarios"
+  },
+  "homepage": "https://github.com/danielthedm/loremcorp#readme",
+  "bugs": {
+    "url": "https://github.com/danielthedm/loremcorp/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.map"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@loremcorp/mocks-shared": "0.1.0",
+    "@loremcorp/personas": "0.1.0",
+    "@loremcorp/engine": "0.1.0",
+    "@loremcorp/company-halcyon": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "node --test dist/*.test.js"
+  }
+}