@shivaedev/test-story 0.0.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+## 0.1.1 - 2026-10-12
+
+### Added
+
+- Story creation, staged hooks, run hooks, traits and bodies can use the runner’s per-test `Scope` without a worker Layer supplying it. Unrelated services still require a matching Layer.
+- `StoryKitDefinition.around` wraps creation, staged seeding and the body while leaving worker acquisition outside the wrapper.
+- `StoryKitDefinition.clock` selects the kit’s default clock; per-story clock options take precedence.
+
+### Changed
+
+- Verify `skip`, `skipIf` and `runIf` in an isolated runner, with passing suite assertions for registration and setup/body non-execution instead of skipped suite tests.
+- Clarify roadmap ownership, failure-narration lifetime and output limits; keep the existing README and `docs/` publication shape.
+- Build package JavaScript, declarations and source maps with TypeScript 7.
+
+## 0.1.0 - 2026-10-06
+
+### Added
+
+- `@shivaedev/test-story/storyKit.ts` exports `storyKit(definition)`, one story kit per engine. The definition names the engine, says how to `create` a fresh one, the optional `layer` that provides its services, the `stages` traits are applied in with an optional `after` hook per stage, the optional `run` hooks (`step`, `maxSteps`, `failed`, `diagnose`), an optional `inspect` and the `verbs` a test acts through. Every hook may be a plain function or a generator function that yields Effects, and every type is inferred from the definition. A hook, trait or test body that needs a service the layer does not provide does not compile.
+- The kit returns `trait`, `traits` and its own `it(name, traits, body, options)`, built on `@shivaedev/effect-test`. Each test starts a fresh engine, seeds the traits stage by stage and runs the body with the verbs and the `story`: its `engine`, `lines`, `tell(line)` and `runUntil(condition, { maxSteps })`. `it.fails`, `it.only`, `it.skip`, `it.runIf` and `it.skipIf` work as in Vitest.
+- Every test of a kit is named after its genre, such as `Bakery Story: steps until the condition holds`, so `-t "Bakery Story: "` picks one engine's stories. `@shivaedev/test-story/genreTags.ts` exports `genreTags(...kitNames)`, which declares a Vitest tag per kit, such as `bakery-story`, for `--tags-filter`. A kit tags its tests only with a genre the config declares, and runs them untagged and silently otherwise.
+- A trait that throws, fails or dies refuses the setup with `the trait "<line>" refused to set up the <engine>: <cause>`, a `help:` line and the thrown value as the error's `cause`. An interrupted trait stays interrupted.
+- `story.runUntil` steps the engine until the condition holds, dies with what `run.failed` reports even when the condition also holds, and after `maxSteps` steps dies with `run.diagnose`. The typed failures of the run hooks and the condition stay in its error channel.
+- A failed story prints under its test's first error: a short guide to reading it, every line in order, a mark where it stopped or on the trait that refused with the spec line there, the engine's state from `inspect` as JSON (written to `node_modules/.cache/test-story/` when longer than 2,000 characters), and the command that reruns the test. The package breaks what it prints at 120 columns, except the story's own lines. A thrown string, plain object or tagged error prints by its content.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+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,286 @@
 # @shivaedev/test-story
 
-Placeholder that reserves the name. Story DSL for tests: domain traits, a staged seed, a story log and a settle loop.
+Tests that read like short English stories and run the real engine. A spec names its setup in domain words, acts through the application's verbs and lets the engine run, so a human sees at a glance what is tested and an agent writes fewer lines to test more of the stack.
+
+## Why you want this
+
+When agents write most of the code, test files grow into hundreds of lines nobody reads. Each test rebuilds its setup by hand, mocks whatever was too much work to build, and hides what it actually checks. A story test holds only what is specific to it:
+
+```ts
+bakery.it("steps until the condition holds", [ovenIsLit(), hasDough(3)], function* ({ oven }) {
+  expect(yield* oven.bakesEverything()).toEqual({ loaves: 3, minutes: 3 });
+});
+```
+
+That is a whole test. `bakery.it` comes from the bakery's story kit. The list holds its traits, `ovenIsLit()` and `hasDough(3)`, which are written once and shared by every spec. `oven.bakesEverything()` is a verb that runs the bakery's real code until the dough is gone. Every story runs the whole engine, so each test also checks the parts its author never thought to mock, and because a spec reads as English, a sloppy test stands out in review.
+
+When a story fails, it prints itself. One of this package's own failing stories expects 2 loaves from one ball of dough, and the test fails with this message:
+
+```text
+loaves: expected 1 to be 2 // Object.is equality
+
+╭─ test-story: how to read the story below
+│ "given" lines are the test's traits, the other lines were told by verbs and engine steps as they ran, and ✗ marks
+│ where the test stopped. The traits, verbs and steps live in the bakery story kit that this test imports.
+╰─
+
+  given  the oven is lit
+  given  the baker has 1 balls of dough
+         1m a loaf comes out of the oven
+✗        the test failed after the line above
+         at src/test-support/failingStories.ts:10:59
+
+The bakery when the test failed:
+{"bowls":1,"capacity":3,"dough":0,"flour":0,"loaves":1,"minute":1,"orders":[],"ovenLit":true,"overfired":false,
+"smoking":false,"starter":false}
+
+Rerun: vitest run src/test-support/failingStories.ts -t "Bakery Story: marks where an assertion stopped the story"
+```
+
+The first line is the assertion's own message. The box under it tells a reader who has never seen the package how to read what follows. Then comes the story: the two traits the test named, the line the bakery told as it baked, and a `✗` where the test stopped, with the spec line it stopped at. Last come the bakery's whole state at that moment and the command that reruns the test, so the failure alone is enough to find the cause.
+
+## Using it
+
+### How to think about it
+
+An application has an **engine**: the real thing a test drives, such as a bakery simulation, a game store or a service with its database. A **story** is one test's run of a fresh engine. It starts from **traits**, sentences of setup in domain words that each change the engine, and goes on through **verbs**, the entry points a user or caller reaches, such as `baker.kneads(2)` or `oven.bakesEverything()`. The engine may also run on its own, one **step** at a time, until something the test waits for holds. Every trait tells a line, and verbs and steps tell what they do, so the story is both the plan the test gave and the trace of what happened, in order.
+
+Every story belongs to a **genre**, the kind of engine it runs. The kit names each of its tests after its genre, such as `Bakery Story: steps until the condition holds`, so a report shows which engine a test runs and one run can pick the bakery's stories and leave the others.
+
+The package runs on Effect and Vitest, but an engine needs neither: every hook, trait and test body may be a plain function. A hook that needs a service or fails with a typed error is a generator function that yields Effects, and the kit runs it, so no definition writes `Effect.gen`.
+
+The work splits into three layers, and each is written by a different hand at a different time:
+
+1. **Once per engine**, a story kit in `test-support/` says how to create the engine, which services it needs, and how to seed, step and show it.
+2. **Once per feature**, traits and verbs in the kit name that feature in domain words.
+3. **In every test**, a spec tells a story with the kit's `it` and checks what a user would see.
+
+### 1. Once per engine: the story kit
+
+`storyKit(definition)` from `@shivaedev/test-story/storyKit.ts` turns one definition into the kit. Every type, the engine's, the stages', the verbs' and the services', is inferred from it.
+
+```ts
+export const bakery = storyKit({
+  after: {
+    *kitchen(state) {
+      if (state.bowls === 0) {
+        return yield* new NoBowls();
+      }
+      state.capacity = state.bowls * DOUGH_PER_BOWL;
+    },
+  },
+  create: emptyBakery,
+  layer: Supplier.layer,
+  name: "bakery",
+  run: {
+    diagnose: stillWaiting,
+    failed: ovenTrouble,
+    maxSteps: 60,
+    *step(state, tell) {
+      state.minute += 1;
+      if (state.overfired) {
+        return yield* new BurntLoaf({ minute: state.minute });
+      }
+      state.dough += state.starter ? 0 : -1;
+      state.loaves += 1;
+      tell(`${state.minute}m a loaf comes out of the oven`);
+    },
+  },
+  stages: ["kitchen", "pantry"],
+  verbs: (state, story) => ({
+    baker: {
+      kneads: (count: number) => {
+        story.tell(`the baker kneads ${count} balls of dough`);
+        state.dough += count;
+      },
+    },
+    oven: {
+      bakesEverything: (maxSteps?: number): Effect.Effect<BakeReport, BurntLoaf> =>
+        story.runUntil((current) => current.dough === 0, { maxSteps }).pipe(Effect.map(() => ({ loaves: state.loaves, minutes: state.minute }))),
+    },
+  }),
+});
+```
+
+This is the bakery kit this package tests itself with. `emptyBakery`, `stillWaiting` and `ovenTrouble` are plain functions beside it. `kitchen` and `step` are generators because they fail with typed errors, `NoBowls` and `BurntLoaf`.
+
+| Hook | Says |
+| --- | --- |
+| `name` | What the engine is called in failures, "the bakery", and the kit's genre, "Bakery Story". |
+| `around(effect)` | Optional. Wraps creation, staged seeding and the body; worker Layer acquisition remains outside it. It may require the worker services and per-test Scope. |
+| `clock` | Optional. `"test"` by default, or `"live"` for HTTP and DOM stories. A story’s `options.clock` takes precedence. |
+| `create()` | A fresh engine. Every story starts from a new one. |
+| `layer` | Optional. The worker Effect layer that provides the services hooks, traits and test bodies use. Per-test Scope is already available to creation, staged and run hooks, traits and bodies. A hook that needs a service the layer does not provide does not compile, and neither does a test whose traits or body need one. |
+| `stages` | The order traits are applied in. A trait names its stage, and one that names a stage the kit does not declare does not compile. |
+| `after` | Optional. A hook per stage that runs once that stage's traits are applied, even when no trait names the stage, so a value it derives is ready before a later stage reads it. Its typed failure fails the test. |
+| `run` | Optional. What `story.runUntil` needs: `step(engine, tell)` advances the engine once and tells what happened, `maxSteps` caps one run, `failed(engine)` returns a sentence when the engine is in a state it cannot recover from, and `diagnose(engine)` says why it has not finished. |
+| `inspect` | Optional. The part of the engine a failure prints. Without it, the failure prints the whole engine. |
+| `verbs(engine, story)` | The entry points a test acts through. A verb that runs the engine returns the Effect from `story.runUntil`. |
+
+Every test of the kit is named `Bakery Story: <its name>`, so `vitest run -t "Bakery Story: "` runs only the bakery's stories with no setup. A project that splits runs by Vitest tags can also tag them:
+
+```ts
+import { genreTags } from "@shivaedev/test-story/genreTags.ts";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: { tags: genreTags("bakery", "mill") },
+});
+```
+
+`genreTags(...kitNames)` declares one tag per kit, named after it: `bakery-story` and `mill-story` here, and `game-store-story` for a kit named "game store". A kit tags its tests only with a genre the config declares, because Vitest refuses a test whose tag the config leaves out, so a config without the line runs every story untagged and prints nothing about it. With the tags declared, `vitest run --tags-filter=mill-story` runs the mill's stories and skips the bakery's, and `--tags-filter` takes any of Vitest's tag expressions, such as `'!mill-story'`. A root config that runs the package's projects by extending its config gets these tags through [`inheritTags`](https://github.com/ShivaeDev/platform/tree/main/packages/quality#inherited-tags) from `@shivaedev/quality`, because Vitest does not pass an extended config's tags on.
+
+### 2. Once per feature: traits and verbs
+
+A trait is a line and a change, tagged with a stage:
+
+```ts
+export function hasDough(count: number) {
+  return bakery.trait("pantry", `the baker has ${count} balls of dough`, (state) => {
+    if (count > state.capacity) {
+      throw new Error(`the bowls hold only ${state.capacity}`);
+    }
+    state.dough = count;
+  });
+}
+
+export function hasFlourDelivered(sacks: number) {
+  return bakery.trait("pantry", `the supplier has delivered ${sacks} sacks of flour`, function* (state) {
+    const supplier = yield* Supplier;
+    yield* supplier.deliver(sacks);
+    state.flour = sacks;
+  });
+}
+
+export function morningShift() {
+  return bakery.traits(ovenIsLit(), hasBowls(1));
+}
+```
+
+`hasDough` is a plain function. `hasFlourDelivered` is a generator because it reaches the `Supplier` service, which the kit's layer provides. `traits(...)` bundles traits into one, so a setup that recurs gets one name. A test may name traits in any order: `[hasDough(6), hasBowls(2)]` fills the bowls only after the kitchen has them.
+
+A trait that throws, fails or dies refuses the setup instead of seeding a state the application could never reach. This package's failing story `bakery.it("marks the trait that refused", [ovenIsLit(), hasDough(4), hasBowls(1)])` asks for more dough than one bowl holds and fails with:
+
+```text
+the trait "the baker has 4 balls of dough" refused to set up the bakery: the bowls hold only 3
+help: a trait throws when the bakery it asks for cannot exist. Give the test traits that fit together, or fix the trait
+      in the bakery story kit if this bakery should be possible.
+
+╭─ test-story: how to read the story below
+│ "given" lines are the test's traits, the other lines were told by verbs and engine steps as they ran, and ✗ marks
+│ where the test stopped. The traits, verbs and steps live in the bakery story kit that this test imports.
+╰─
+
+  given  the oven is lit
+✗ given  the baker has 4 balls of dough
+         refused at src/test-support/failingStories.ts:13:57
+  given  the bakery has 1 bowls
+
+The bakery when the test failed:
+{"bowls":1,"capacity":3,"dough":0,"flour":0,"loaves":0,"minute":0,"orders":[],"ovenLit":true,"overfired":false,
+"smoking":false,"starter":false}
+
+Rerun: vitest run src/test-support/failingStories.ts -t "Bakery Story: marks the trait that refused"
+```
+
+The first line names the trait and what it threw, which the error also keeps as its `cause`, and the `help:` line says what to change. The `✗` marks the trait that refused, and the line under it points at the spec line that named it. A trait that fails with a string, a plain object or a tagged error prints by its content, never as `[object Object]`, and an interrupted trait stays interrupted.
+
+A verb that a feature adds goes into the kit's `verbs`. It acts through the engine's real entry point and tells a line, so the story shows it.
+
+### 3. In every test: a spec
+
+```ts
+bakery.it("tells each step into the story", [ovenIsLit()], function* ({ baker, oven, story }) {
+  baker.kneads(2);
+  yield* oven.bakesEverything();
+
+  expect(story.lines).toEqual([
+    "the oven is lit",
+    "the baker kneads 2 balls of dough",
+    "1m a loaf comes out of the oven",
+    "2m a loaf comes out of the oven",
+  ]);
+});
+```
+
+`kit.it(name, traits, body, options)` declares one Vitest test, named after the kit's genre: `Bakery Story: tells each step into the story`. It starts a fresh engine, seeds the traits stage by stage and runs the body with the kit's verbs and the `story`: its `engine`, `lines`, `tell(line)` and `runUntil`. The body's second argument is Vitest's test context. A body that yields Effects, such as a verb that runs the engine, is a generator, and one that yields nothing is a plain function. A test that only checks that its traits refuse may leave the body out. `options` is a timeout in milliseconds or Vitest's test options, whose own `tags` join the genre tag when the config declares it. `it.fails`, `it.only`, `it.skip`, `it.runIf(condition)` and `it.skipIf(condition)` work as they do in Vitest.
+
+A spec starts a story, acts through verbs and checks what a user would see. When it needs a setup or an action the kit lacks, add a trait or verb to the kit instead of building it in the spec.
+
+### Running the engine
+
+`story.runUntil(condition, { maxSteps })` returns an Effect that asks three questions before every step:
+
+1. `run.failed` returns a sentence: it dies with it, even when the condition also holds.
+2. The condition holds: it succeeds.
+3. `maxSteps` steps have run, or the kit's `run.maxSteps` when the call names none: it dies with `run.diagnose`.
+
+```text
+the bakery ran 12 steps and never reached what runUntil waits for: 1 balls of dough still wait after 12 minutes: the
+  sourdough starter never runs out
+help: either the bakery never gets there, so check the setup and the engine, or it needs more steps, so pass a larger
+      maxSteps to runUntil.
+```
+
+That is what `oven.bakesEverything(12)` dies with when the baker keeps a sourdough starter, so the dough never runs out. The typed failures of `step`, `failed`, `diagnose` and the condition stay in the Effect's error channel: a step that fails with `BurntLoaf` gives the test a `BurntLoaf` to assert on. A kit without `run` hooks dies with a message that says to add them.
+
+### When a story fails
+
+After the engine has been created, a failing story test adds the story to its first error, as in the examples above:
+
+- a short guide to reading the story, in a box;
+- every line in order, traits marked `given`;
+- `✗` after the last line, on the trait that refused, or alone when the test failed before the story told a line, and under it the spec line where the test stopped or that named the refusing trait;
+- the engine's state from `inspect` as JSON, broken between its fields to fit 120 columns. State longer than 2,000 characters is written to `node_modules/.cache/test-story/` under the working directory, and the failure names the file;
+- the command that reruns the test, with `-t` on a second line when one line would pass 120 columns.
+
+The package wraps between words or JSON fields toward 120 columns and prints the story's own lines whole. An indivisible word, field or rerun command component can exceed that width. A passing test adds nothing. A typed failure with no message, such as an `after` hook's `NoBowls`, prints by its tag.
+
+### Whole-stack application kits
+
+Keep one kit in the application’s `test-support/`. `effect-test` owns Vitest registration, worker Layer acquisition, the per-test Scope, cancellation and clock selection. `test-story` owns engine creation, staged traits, verbs and narration. The application owns database lifecycle, migrations, isolation, seeds, actual server/client wiring and screen interactions.
+
+The [order feature kit](https://github.com/ShivaeDev/platform/tree/main/packages/effect-react/src/test-support/order-example) runs the existing feature’s services, repository, contracts, JSON serialization and authentication middleware over a loopback HTTP listener. Its [stories](https://github.com/ShivaeDev/platform/blob/main/packages/effect-react/src/orderStory.dom.spec.tsx) test visible commits through a separate PostgreSQL pool, rollback of a rejected write without publication, cross-owner rejection, a native React action refreshing a list, and an editor retaining rejected input before a corrected save.
+
+```ts
+import { app, realPostgres } from "./test-support/application.ts";
+import { aliceHasOrder } from "./test-support/traits.ts";
+
+app.it("a save commits and a rejected write leaves storage intact", [realPostgres(), aliceHasOrder("paper")], function* ({ saveOrder, rejectOrder, storedOrderIs, changesAre }) {
+  yield* saveOrder("paper", "Office chairs", 8);
+  yield* storedOrderIs("paper", "Office chairs", 8);
+  yield* rejectOrder("paper", -1);
+  yield* storedOrderIs("paper", "Office chairs", 8);
+  yield* changesAre(1);
+});
+```
+
+The application’s worker Layer leases a uniquely named disposable database, opens native PgClient pools and runs `migratePostgres`. Multiple kits in the worker share the database; the last lease drops it after the pools close. The PostgreSQL trait checks that infrastructure and the declared policy; it does not start a database. The application validates its local disposable destination before database creation or reset and skips database stories without `PLATFORM_EFFECT_SQL_TEST_DATABASE_URL`. Tests sharing that database run serially; parallelism belongs between workers or inside one story.
+
+| Application mode | Reset policy | Transaction policy | Coverage |
+| --- | --- | --- | --- |
+| HTTP | Truncate application tables and restart identities before and after the story; retain the migration ledger. | Commands perform real commits. | RPC serialization/transport, independent persistence reads, React refresh and forms. |
+| Local | Reset the baseline before and after the story. | Wrap creation, seeds and body in an outer Platform `transact`, then force rollback after success with a private sentinel. | Local repositories and services, transactional seeds and nested writes. |
+
+The kit’s `around` implements that policy. HTTP requests run in separate fibers, so an outer test transaction cannot isolate their writes. Local rollback starts with Platform `transact`; putting it inside a native outer transaction violates transaction ownership. Catch only the wrapper’s private rollback sentinel, let other failures escape, and check independent storage before cleanup truncation so cleanup cannot hide an accidental commit.
+
+Application-authored seed builders reuse application schemas, validate overrides, insert actual rows and return generated values. Traits retain aliases such as `"paper"` so specs avoid generated IDs. There is no shared factory or automatic relationship seeding.
+
+React screen traits acquire roots in Scope and use a fresh native atom registry for each screen. Cleanup unmounts roots before disposing registries and servers. Screen verbs dispatch DOM events and use bounded observations of rendered output. Select a live clock once on an HTTP/DOM kit; keep TestClock for deterministic local stories. `runUntil` is for engines with a meaningful step hook, not HTTP or DOM polling. Creation forms can use the same pattern with the existing `useCreate` path.
+
+The example proves DOM and loopback HTTP behavior, not browser credentials, BetterAuth cookies, SSR, mobile or a deployed proxy. Native `RpcTest` can exercise handlers in faster local stories, but omits serialization and transport. Failure inspection is synchronous: keep redacted observed values in the engine instead of trying to query PostgreSQL inside `inspect`.
+
+### Install and limits
+
+```sh
+pnpm add --save-dev @shivaedev/test-story @effect/vitest@4.0.0-rc.112 effect@4.0.0-rc.112 vitest@4.1.11
+```
+
+`@effect/vitest`, `effect` and `vitest` are peers, so the application's own versions run the stories.
+
+- The package runs inside Vitest. The story reaches the failure by rewriting the first error's message in Vitest's `onTestFailed` hook.
+- Layer acquisition and engine creation failures precede that hook and carry no story appendix. A printed rerun command still needs a Vitest configuration that collects its file; the intentional `failingStories.ts` examples use the package's explicit fixture runner.
+- A kit's `it` is created when the kit is defined, so a kit lives in a module that only Vitest test files import.
+- `inspect` runs after the test has failed, so it reads the engine synchronously.
+- The spec line under the `✗` is found by matching the spec's path in the failure's stack, or else in the call site of the last line the story told or the last `runUntil`. A failure raised inside an Effect that the spec does not call directly may have none.
+- The package is built for ShivaeDev applications and may change without a deprecation period.

package/dist/genreTags.d.ts

@@ -0,0 +1,6 @@
+export interface GenreTag {
+    readonly description: string;
+    readonly name: string;
+}
+export declare function genreTags(...kitNames: readonly string[]): GenreTag[];
+//# sourceMappingURL=genreTags.d.ts.map

package/dist/genreTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genreTags.d.ts","sourceRoot":"","sources":["../src/genreTags.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CAAC,GAAG,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,EAAE,CAEpE"}

package/dist/genreTags.js

@@ -0,0 +1,5 @@
+import { genreOf } from "#internal/genre.ts";
+export function genreTags(...kitNames) {
+    return kitNames.map((kitName) => genreOf(kitName).tag);
+}
+//# sourceMappingURL=genreTags.js.map

package/dist/genreTags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"genreTags.js","sourceRoot":"","sources":["../src/genreTags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAO7C,MAAM,UAAU,SAAS,CAAC,GAAG,QAA2B;IACvD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC;AACxD,CAAC"}

package/dist/internal/callSite.d.ts

@@ -0,0 +1,3 @@
+export declare function callSite(): Error;
+export declare function locate(stack: string | undefined, testFile: string): string | undefined;
+//# sourceMappingURL=callSite.d.ts.map

package/dist/internal/callSite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callSite.d.ts","sourceRoot":"","sources":["../../src/internal/callSite.ts"],"names":[],"mappings":"AAMA,wBAAgB,QAAQ,IAAI,KAAK,CAMhC;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAItF"}

package/dist/internal/callSite.js

@@ -0,0 +1,17 @@
+import { relative } from "node:path";
+import process from "node:process";
+const FRAMES = 50;
+// V8 formats a stack only when it is read, so a site costs little until a test fails.
+export function callSite() {
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = FRAMES;
+    const site = new Error("call site");
+    Error.stackTraceLimit = limit;
+    return site;
+}
+export function locate(stack, testFile) {
+    const frame = stack?.split("\n").find((line) => line.includes(testFile));
+    const position = frame?.slice(frame.indexOf(testFile) + testFile.length).match(/^:(?<line>\d+):(?<column>\d+)/u)?.groups;
+    return position === undefined ? undefined : `${relative(process.cwd(), testFile)}:${position.line}:${position.column}`;
+}
+//# sourceMappingURL=callSite.js.map

package/dist/internal/callSite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callSite.js","sourceRoot":"","sources":["../../src/internal/callSite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,OAAO,MAAM,cAAc,CAAC;AAEnC,MAAM,MAAM,GAAG,EAAE,CAAC;AAElB,sFAAsF;AACtF,MAAM,UAAU,QAAQ;IACvB,MAAM,KAAK,GAAG,KAAK,CAAC,eAAe,CAAC;IACpC,KAAK,CAAC,eAAe,GAAG,MAAM,CAAC;IAC/B,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC;IACpC,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC;IAC9B,OAAO,IAAI,CAAC;AACb,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,KAAyB,EAAE,QAAgB;IACjE,MAAM,KAAK,GAAG,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IACzE,MAAM,QAAQ,GAAG,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC,EAAE,MAAM,CAAC;IACzH,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;AACxH,CAAC"}

package/dist/internal/engineSnapshot.d.ts

@@ -0,0 +1,4 @@
+import type { FailedTest } from "#internal/failureReport.ts";
+import type { Subject } from "#internal/narration.ts";
+export declare function engineSnapshot<TEngine>(subject: Subject<TEngine>, test: FailedTest): string[];
+//# sourceMappingURL=engineSnapshot.d.ts.map

package/dist/internal/engineSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineSnapshot.d.ts","sourceRoot":"","sources":["../../src/internal/engineSnapshot.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAuBtD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAoB7F"}

package/dist/internal/engineSnapshot.js

@@ -0,0 +1,36 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import process from "node:process";
+import { describeValue, toJson } from "#internal/render.ts";
+import { WIDTH, wrap, wrapJson } from "#internal/wrap.ts";
+const INLINE_CHARACTERS = 2000;
+function snapshot(subject) {
+    try {
+        return { value: subject.inspect === undefined ? subject.engine : subject.inspect(subject.engine) };
+    }
+    catch (threw) {
+        return { threw };
+    }
+}
+function slug(text) {
+    return text
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9.]+/gu, "-")
+        .slice(0, 80);
+}
+export function engineSnapshot(subject, test) {
+    const heading = `The ${subject.name} when the test failed`;
+    const taken = snapshot(subject);
+    if ("threw" in taken) {
+        return wrap(`${heading} is unknown: its inspect hook threw ${describeValue(taken.threw)}`);
+    }
+    const json = toJson(taken.value);
+    if (json.length <= INLINE_CHARACTERS) {
+        return heading.length + 2 + json.length > WIDTH ? [`${heading}:`, ...wrapJson(json)] : [`${heading}: ${json}`];
+    }
+    const file = join(process.cwd(), "node_modules", ".cache", "test-story", `${slug(basename(test.file))}--${slug(test.name)}--${slug(subject.name)}.json`);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, toJson(taken.value, 2));
+    return wrap(`${heading} is ${json.length} characters of JSON, too long to print here. Read it in ${relative(process.cwd(), file)}`);
+}
+//# sourceMappingURL=engineSnapshot.js.map

package/dist/internal/engineSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineSnapshot.js","sourceRoot":"","sources":["../../src/internal/engineSnapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,OAAO,MAAM,cAAc,CAAC;AAGnC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAI/B,SAAS,QAAQ,CAAU,OAAyB;IACnD,IAAI,CAAC;QACJ,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;IACpG,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,KAAK,EAAE,CAAC;IAClB,CAAC;AACF,CAAC;AAED,SAAS,IAAI,CAAC,IAAY;IACzB,OAAO,IAAI;SACT,WAAW,EAAE;SACb,UAAU,CAAC,eAAe,EAAE,GAAG,CAAC;SAChC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,cAAc,CAAU,OAAyB,EAAE,IAAgB;IAClF,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,uBAAuB,CAAC;IAC3D,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IAChC,IAAI,OAAO,IAAI,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,GAAG,OAAO,uCAAuC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5F,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACjC,IAAI,IAAI,CAAC,MAAM,IAAI,iBAAiB,EAAE,CAAC;QACtC,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,KAAK,IAAI,EAAE,CAAC,CAAC;IAChH,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAChB,OAAO,CAAC,GAAG,EAAE,EACb,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAC9E,CAAC;IACF,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5C,OAAO,IAAI,CAAC,GAAG,OAAO,OAAO,IAAI,CAAC,MAAM,2DAA2D,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;AACrI,CAAC"}

package/dist/internal/errors.d.ts

@@ -0,0 +1,5 @@
+export declare function refusal(name: string, line: string, cause: unknown): Error;
+export declare function broken(name: string, steps: number, reason: string): Error;
+export declare function unfinished(name: string, steps: number, diagnosis: string | undefined): Error;
+export declare function cannotRun(name: string): Error;
+//# sourceMappingURL=errors.d.ts.map

package/dist/internal/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/internal/errors.ts"],"names":[],"mappings":"AAGA,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,CAQzE;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAOzE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,CAO5F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAO7C"}

package/dist/internal/errors.js

@@ -0,0 +1,15 @@
+import { describeValue } from "#internal/render.ts";
+import { explained } from "#internal/wrap.ts";
+export function refusal(name, line, cause) {
+    return new Error(explained(`the trait "${line}" refused to set up the ${name}: ${describeValue(cause)}`, `a trait throws when the ${name} it asks for cannot exist. Give the test traits that fit together, or fix the trait in the ${name} story kit if this ${name} should be possible.`), { cause });
+}
+export function broken(name, steps, reason) {
+    return new Error(explained(`the ${name} broke after ${steps} steps: ${reason}`, `run.failed in the ${name} story kit reports a state the ${name} cannot recover from. The story printed with this failure shows the setup and steps that led here.`));
+}
+export function unfinished(name, steps, diagnosis) {
+    return new Error(explained(`the ${name} ran ${steps} steps and never reached what runUntil waits for${diagnosis === undefined ? "" : `: ${diagnosis}`}`, `either the ${name} never gets there, so check the setup and the engine, or it needs more steps, so pass a larger maxSteps to runUntil.`));
+}
+export function cannotRun(name) {
+    return new Error(explained(`the ${name} story kit has no run hooks, so runUntil cannot step the ${name}`, `give the ${name} story kit run: { maxSteps, step }, where step advances the ${name} by one step.`));
+}
+//# sourceMappingURL=errors.js.map

package/dist/internal/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,IAAY,EAAE,KAAc;IACjE,OAAO,IAAI,KAAK,CACf,SAAS,CACR,cAAc,IAAI,2BAA2B,IAAI,KAAK,aAAa,CAAC,KAAK,CAAC,EAAE,EAC5E,2BAA2B,IAAI,8FAA8F,IAAI,sBAAsB,IAAI,sBAAsB,CACjL,EACD,EAAE,KAAK,EAAE,CACT,CAAC;AACH,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,IAAY,EAAE,KAAa,EAAE,MAAc;IACjE,OAAO,IAAI,KAAK,CACf,SAAS,CACR,OAAO,IAAI,gBAAgB,KAAK,WAAW,MAAM,EAAE,EACnD,qBAAqB,IAAI,kCAAkC,IAAI,oGAAoG,CACnK,CACD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,KAAa,EAAE,SAA6B;IACpF,OAAO,IAAI,KAAK,CACf,SAAS,CACR,OAAO,IAAI,QAAQ,KAAK,mDAAmD,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,EAAE,EAC5H,cAAc,IAAI,sHAAsH,CACxI,CACD,CAAC;AACH,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,IAAY;IACrC,OAAO,IAAI,KAAK,CACf,SAAS,CACR,OAAO,IAAI,4DAA4D,IAAI,EAAE,EAC7E,YAAY,IAAI,+DAA+D,IAAI,eAAe,CAClG,CACD,CAAC;AACH,CAAC"}

package/dist/internal/failureReport.d.ts

@@ -0,0 +1,8 @@
+import type { Narration, Subject } from "#internal/narration.ts";
+export interface FailedTest {
+    readonly file: string;
+    readonly name: string;
+    readonly stack: string | undefined;
+}
+export declare function failureReport<TEngine>(narration: Narration, subject: Subject<TEngine>, test: FailedTest): string;
+//# sourceMappingURL=failureReport.d.ts.map

package/dist/internal/failureReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failureReport.d.ts","sourceRoot":"","sources":["../../src/internal/failureReport.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAIjE,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAMhH"}

package/dist/internal/failureReport.js

@@ -0,0 +1,41 @@
+import { relative } from "node:path";
+import process from "node:process";
+import { locate } from "#internal/callSite.ts";
+import { engineSnapshot } from "#internal/engineSnapshot.ts";
+import { describeValue } from "#internal/render.ts";
+import { WIDTH, wrap } from "#internal/wrap.ts";
+export function failureReport(narration, subject, test) {
+    try {
+        return [...guide(subject.name), "", ...storyRows(narration, test), "", ...engineSnapshot(subject, test), "", rerun(test)].join("\n");
+    }
+    catch (error) {
+        return `test-story could not print the story of this ${subject.name}: ${describeValue(error)}`;
+    }
+}
+function guide(name) {
+    return [
+        "╭─ test-story: how to read the story below",
+        ...wrap(`"given" lines are the test's traits, the other lines were told by verbs and engine steps as they ran, and ✗ marks where the test stopped. The traits, verbs and steps live in the ${name} story kit that this test imports.`, { first: "│ ", rest: "│ " }),
+        "╰─",
+    ];
+}
+function storyRows(narration, test) {
+    const rows = narration.lines.map((line, index) => `${narration.refused?.index === index ? "✗" : " "} ${index < narration.given ? "given" : "     "}  ${line}`);
+    if (narration.refused !== undefined) {
+        const where = locate(narration.sites[narration.refused.index]?.stack, test.file);
+        rows.splice(narration.refused.index + 1, 0, ...(where === undefined ? [] : [`         refused at ${where}`]));
+        return rows;
+    }
+    const where = locate(test.stack, test.file) ?? locate(narration.at?.stack, test.file);
+    return [
+        ...rows,
+        `✗        the test failed ${rows.length === 0 ? "before the story told a line" : "after the line above"}`,
+        ...(where === undefined ? [] : [`         at ${where}`]),
+    ];
+}
+function rerun(test) {
+    const run = `Rerun: vitest run ${relative(process.cwd(), test.file)}`;
+    const filter = `-t "${test.name.replaceAll(/[$()*+.?[\\\]^{|}]/gu, "\\$&")}"`;
+    return run.length + 1 + filter.length > WIDTH ? `${run} \\\n  ${filter}` : `${run} ${filter}`;
+}
+//# sourceMappingURL=failureReport.js.map

package/dist/internal/failureReport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failureReport.js","sourceRoot":"","sources":["../../src/internal/failureReport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,OAAO,MAAM,cAAc,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAQhD,MAAM,UAAU,aAAa,CAAU,SAAoB,EAAE,OAAyB,EAAE,IAAgB;IACvG,IAAI,CAAC;QACJ,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtI,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,gDAAgD,OAAO,CAAC,IAAI,KAAK,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;IAChG,CAAC;AACF,CAAC;AAED,SAAS,KAAK,CAAC,IAAY;IAC1B,OAAO;QACN,4CAA4C;QAC5C,GAAG,IAAI,CACN,qLAAqL,IAAI,oCAAoC,EAC7N,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAC3B;QACD,IAAI;KACJ,CAAC;AACH,CAAC;AAED,SAAS,SAAS,CAAC,SAAoB,EAAE,IAAgB;IACxD,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAC/B,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI,EAAE,CAC5H,CAAC;IACF,IAAI,SAAS,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACrC,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QACjF,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,uBAAuB,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9G,OAAO,IAAI,CAAC;IACb,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACtF,OAAO;QACN,GAAG,IAAI;QACP,4BAA4B,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC,sBAAsB,EAAE;QACzG,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,KAAK,EAAE,CAAC,CAAC;KACxD,CAAC;AACH,CAAC;AAED,SAAS,KAAK,CAAC,IAAgB;IAC9B,MAAM,GAAG,GAAG,qBAAqB,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IACtE,MAAM,MAAM,GAAG,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,EAAE,MAAM,CAAC,GAAG,CAAC;IAC9E,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,UAAU,MAAM,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,MAAM,EAAE,CAAC;AAC/F,CAAC"}

package/dist/internal/genre.d.ts

@@ -0,0 +1,7 @@
+import type { GenreTag } from "#genreTags.ts";
+export interface Genre {
+    readonly tag: GenreTag;
+    readonly title: string;
+}
+export declare function genreOf(kitName: string): Genre;
+//# sourceMappingURL=genre.d.ts.map

package/dist/internal/genre.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genre.d.ts","sourceRoot":"","sources":["../../src/internal/genre.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,MAAM,WAAW,KAAK;IACrB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAM9C"}

package/dist/internal/genre.js

@@ -0,0 +1,8 @@
+export function genreOf(kitName) {
+    const words = kitName.trim().split(/\s+/u);
+    return {
+        tag: { description: `stories over a real ${words.join(" ")}`, name: [...words.map((word) => word.toLowerCase()), "story"].join("-") },
+        title: [...words, "story"].map((word) => `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(" "),
+    };
+}
+//# sourceMappingURL=genre.js.map

package/dist/internal/genre.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"genre.js","sourceRoot":"","sources":["../../src/internal/genre.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,OAAO,CAAC,OAAe;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3C,OAAO;QACN,GAAG,EAAE,EAAE,WAAW,EAAE,uBAAuB,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACrI,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;KACrG,CAAC;AACH,CAAC"}

package/dist/internal/hooked.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+export type AnyEffect = Effect.Effect<unknown, unknown, unknown>;
+export type Hook<TArguments extends readonly unknown[], TEffect extends AnyEffect, A> = (...input: TArguments) => Generator<TEffect, A, never> | A;
+export type ErrorOf<TEffect> = [TEffect] extends [never] ? never : [TEffect] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never;
+export type ServicesOf<TEffect> = [TEffect] extends [never] ? never : [TEffect] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never;
+export declare function hooked<TEffect extends AnyEffect, A>(call: () => Generator<TEffect, A, never> | A): Effect.Effect<A, ErrorOf<TEffect>, ServicesOf<TEffect>>;
+//# sourceMappingURL=hooked.d.ts.map

package/dist/internal/hooked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooked.d.ts","sourceRoot":"","sources":["../../src/internal/hooked.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;AAEjE,MAAM,MAAM,IAAI,CAAC,UAAU,SAAS,SAAS,OAAO,EAAE,EAAE,OAAO,SAAS,SAAS,EAAE,CAAC,IAAI,CAAC,GAAG,KAAK,EAAE,UAAU,KAAK,SAAS,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;AAEnJ,MAAM,MAAM,OAAO,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE9I,MAAM,MAAM,UAAU,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAMjJ,wBAAgB,MAAM,CAAC,OAAO,SAAS,SAAS,EAAE,CAAC,EAClD,IAAI,EAAE,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,GAC1C,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAKzD"}

package/dist/internal/hooked.js

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+function isGenerator(value) {
+    return typeof value === "object" && value !== null && Symbol.iterator in value && "next" in value && typeof value.next === "function";
+}
+export function hooked(call) {
+    return Effect.suspend(() => {
+        const result = call();
+        return isGenerator(result) ? Effect.gen(() => result) : Effect.succeed(result);
+    });
+}
+//# sourceMappingURL=hooked.js.map

package/dist/internal/hooked.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooked.js","sourceRoot":"","sources":["../../src/internal/hooked.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAUhC,SAAS,WAAW,CAAa,KAAuC;IACvE,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,CAAC,QAAQ,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC;AACvI,CAAC;AAED,MAAM,UAAU,MAAM,CACrB,IAA4C;IAE5C,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;QAC1B,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC;QACtB,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAChF,CAAC,CAAC,CAAC;AACJ,CAAC"}