koota-kit 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project are documented here. This project follows
+[Semantic Versioning](https://semver.org/) and uses
+[Conventional Commits](https://www.conventionalcommits.org/) to drive releases.
+
+## Unreleased
+
+### Added
+
+- Release-ready `@jbdevprimary/koota-kit` package with ESM and CommonJS entry
+  points.
+- Idempotent world teardown and validated, atomic snapshot restoration.
+- Independent deterministic `gen` and `events` random streams.
+- Compile-time and runtime guards for object-valued Koota traits.
+- World-scoped event logs with consuming and observational read paths.
+- Runnable examples, package-consumer checks, API/architecture documentation,
+  and Node 22/24 Linux plus Node 24 Windows CI coverage.
+- Repository-level LF normalization so formatter checks behave identically on
+  Windows, macOS, and Linux checkouts.
+
+### Changed
+
+- `WorldHandle.world`, `WorldHandle.seeds`, and `WorldHandle.scratch` are
+  readonly references; seed values are copied and frozen at creation.
+- Invalid RNG bounds, probabilities, clock values, event-log keys, and
+  persisted headers now fail with `TypeError` or `RangeError` instead of
+  producing invalid state.

package/CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Contributing
+
+Thanks for taking the time to contribute.
+
+## Getting set up
+
+With [mise](https://mise.jdx.dev) (recommended — installs the Node and pnpm
+versions pinned in `mise.toml`):
+
+```sh
+mise install
+pnpm install
+pnpm verify   # lint, typecheck, test, build — the same gate CI runs
+```
+
+Without mise, use `corepack` so pnpm matches the version pinned in
+`package.json#packageManager`, on any Node release in the `engines.node`
+range (`>=22`; CI verifies 22, 24, and 26 with the official
+`actions/setup-node` + `pnpm/action-setup`):
+
+```sh
+corepack enable
+pnpm install
+pnpm verify
+```
+
+## Making a change
+
+1. Branch off `main`.
+2. Write the test first. A bug fix should come with a test that fails without it.
+3. Run `pnpm verify`. A change is not ready while any part of that is red.
+4. Commit with [Conventional Commits](https://www.conventionalcommits.org):
+   `fix:`, `feat:`, `docs:`, `refactor:`, `test:`, `chore:`. Release Please uses
+   these commits to drive the changelog and next version number.
+5. Open a pull request describing what changed and why.
+
+## What gets reviewed
+
+- Does it do what it says, and is there a test proving it?
+- Does it keep the public API honest? A breaking change needs a `!` or a
+  `BREAKING CHANGE:` footer.
+- Are the types right for consumers? CI runs `publint` and
+  `arethetypeswrong` because broken types only surface at integration time.
+- Do invalid inputs fail before changing clock, RNG, or restored state?
+- Does the change keep Koota-facing behavior aligned with the supported peer?
+
+## Releases
+
+Releases are automated. Merging a conventional commit to `main` opens a
+release pull request; merging that publishes to npm with provenance. Do not
+hand-edit versions or the changelog.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jon Bogaty
+
+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

@@ -0,0 +1,215 @@
+# koota-kit
+
+![Two deterministic streams—world generation and runtime events—flow through a simulation clock into modular ECS components.](./docs/assets/koota-kit-hero.webp)
+
+[![CI](https://github.com/jbcom/koota-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/jbcom/koota-kit/actions/workflows/ci.yml)
+[![MIT license](https://img.shields.io/badge/license-MIT-17324d.svg)](./LICENSE)
+
+Small, production-derived conventions for deterministic simulations built with
+[Koota](https://github.com/pmndrs/koota). koota-kit gives a simulation one
+lifecycle boundary, two independent seeded random streams, safe object-valued
+traits, and world-scoped event logs.
+
+It is deliberately **not a game engine**. It is the narrow layer that prevents
+recurring classes of simulation bug without hiding Koota's queries,
+entities, relations, or actions.
+
+Full documentation: **[jonbogaty.com/koota-kit](https://jonbogaty.com/koota-kit/)**
+
+## Why use it?
+
+| Problem | koota-kit convention |
+| --- | --- |
+| World generation changes after unrelated gameplay draws | Separate `gen` and `events` RNG streams |
+| A loaded save no longer reproduces the next random result | Byte-exact, JSON-safe RNG snapshots |
+| Object state leaks between entities | `defineTrait` requires per-entity factories |
+| A HUD or test consumes an event before its real system sees it | Single-consumer `drain`, non-consuming `peek` |
+| Replaced worlds retain caches or process-global Koota IDs | `createSimWorld` / idempotent `destroySimWorld` lifecycle |
+
+## Install
+
+```sh
+pnpm add koota-kit koota
+```
+
+Requirements:
+
+- Node.js 22 or newer (CI covers Node 22/24/26 on Linux and Node 24 on Windows)
+- Koota `^0.6.6`, installed by the application as a peer dependency
+
+The package ships native ESM and CommonJS entry points with format-correct
+TypeScript declarations.
+
+## Quick start
+
+```ts
+import {
+  advanceClock,
+  createSimWorld,
+  defineEventLog,
+  defineTrait,
+  destroySimWorld,
+  nextInt,
+  snapshotWorld,
+} from "koota-kit";
+
+const Position = defineTrait({ x: 0, y: 0 });
+const Inventory = defineTrait({ items: () => [] as string[] });
+const moved = defineEventLog<{ entity: number; distance: number }>("movement:completed");
+
+const sim = createSimWorld({ gen: "map-42", events: "run-1" });
+
+try {
+  const scout = sim.world.spawn(Position({ x: 4, y: 9 }), Inventory());
+
+  advanceClock(sim, 1 / 60);
+  const distance = nextInt(sim.rng.events, 1, 5);
+  const position = scout.get(Position);
+  if (position) scout.set(Position, { ...position, x: position.x + distance });
+  moved.push(sim, { entity: Number(scout), distance });
+
+  // The owning system consumes each event once.
+  for (const event of moved.drain(sim)) {
+    console.log(event);
+  }
+
+  // Save this beside your own serialized entity/trait state.
+  const header = snapshotWorld(sim);
+  const serializedHeader = JSON.stringify(header);
+  console.log(serializedHeader);
+} finally {
+  destroySimWorld(sim);
+}
+```
+
+Runnable ESM and CommonJS versions live in [`examples/`](./examples).
+
+## Core concepts
+
+### One handle owns one simulation
+
+`createSimWorld` creates a Koota world, immutable seed values, independent RNG
+streams, a fixed-step clock, and a scratch map. `destroySimWorld` clears the
+scratch map and releases Koota's world ID; it is safe to call more than once.
+
+The scratch map is for derived, non-serializable caches and short-lived
+coordination state. Namespace keys by system, for example `pathfinding:grid`
+or `combat:hits`.
+
+### Randomness has two jobs
+
+- `rng.gen` defines stable world content: terrain, layouts, initial spawns.
+- `rng.events` defines play history: combat rolls, weather, runtime events.
+
+Never key per-entity randomness on packed Koota entity IDs or consume a shared
+stream in query iteration order. Entity IDs contain process-global world and
+generation bits. Derive a local stream from a stable domain key instead:
+
+```ts
+import { createRng, nextU32 } from "koota-kit/rng";
+
+const tileRng = createRng({
+  gen: `${String(sim.seeds.gen)}/tile:12,8`,
+  events: 0,
+});
+const terrainVariant = nextU32(tileRng.gen);
+```
+
+### Object-valued traits need factories
+
+Koota's structure-of-arrays layout can alias a bare object literal across
+entities. koota-kit rejects that form at compile time and runtime:
+
+```ts
+defineTrait({ storage: () => ({ logs: 0 }) }); // correct: one object per entity
+defineTrait({ storage: { logs: 0 } });         // TypeError: shared object footgun
+```
+
+Declare traits once in a leaf module and export each trait from one location.
+Koota identifies traits by reference, not by a string name.
+
+### Event logs have one consuming owner
+
+`push` appends, `drain` returns every pending event and empties the log, and
+`peek` returns a copy without consuming. A devtool, HUD, or test should peek;
+the system responsible for acting on the event should drain.
+
+## Persistence boundary
+
+`snapshotWorld` stores the clock and both RNG states. It intentionally does not
+serialize entities or traits: those are application data with application-
+specific schemas and migrations. `restoreWorldHeader` validates a parsed save
+before changing the handle and restores atomically.
+
+Persist a version beside the header and your ECS state so the application can
+migrate its own schema.
+
+## API and architecture
+
+The root package exports the full API. Focused entry points are also available:
+
+| Entry point | Purpose |
+| --- | --- |
+| `koota-kit/world` | World lifecycle, clock, Koota facade, world snapshots |
+| `koota-kit/rng` | Seeded streams, bounded draws, snapshots |
+| `koota-kit/traits` | Safe trait declaration |
+| `koota-kit/eventLog` | World-scoped publish/drain logs |
+
+See the [API reference](./docs/API.md) for signatures and validation behavior,
+and [architecture notes](./docs/ARCHITECTURE.md) for module boundaries and
+invariants.
+
+## Errors and edge cases
+
+- Seeds must be strings or finite numbers.
+- `advanceClock` accepts finite, non-negative `dt`; `0` is a valid paused tick.
+- `nextInt` requires safe-integer bounds with `maxExclusive > minInclusive` and
+  a range no larger than `2**32`.
+- `chance` accepts only finite probabilities in `[0, 1]`.
+- Restores reject malformed RNG or clock state before mutating the handle.
+- Event-log keys must be non-empty and cannot reuse a scratch key holding a
+  non-array cache.
+
+Invalid caller input raises `TypeError` or `RangeError` with the API name in the
+message. No validation failure consumes RNG state or partially restores a
+world header.
+
+## Development
+
+```sh
+mise install   # or: corepack enable
+pnpm install --frozen-lockfile
+pnpm verify
+```
+
+Node and pnpm versions live in `mise.toml`; CI verifies against the full
+supported Node range (22, 24, 26).
+
+`pnpm verify` runs formatting/lint checks, strict TypeScript, the full test
+suite with 100% coverage thresholds, dual-format builds, both runnable
+examples, `publint`, Are The Types Wrong, and package-content/runtime checks.
+
+Useful individual commands:
+
+```sh
+pnpm test             # fast behavior suite
+pnpm test:watch       # local watch mode
+pnpm coverage         # tests plus enforced coverage thresholds
+pnpm build            # dist/esm and dist/cjs
+pnpm package:check    # exports, declarations, packed files, ESM/CJS parity
+pnpm audit --prod     # registry-backed production dependency audit
+```
+
+## Releases and support
+
+Release Please maintains versions and `CHANGELOG.md` from Conventional
+Commits. A release tag triggers a clean verification and npm publication with
+provenance. The latest `0.x` release receives fixes; pre-1.0 APIs may evolve,
+with breaking changes called out in the changelog.
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) before opening a pull request. Report
+security issues privately according to [SECURITY.md](./SECURITY.md).
+
+## License
+
+[MIT](./LICENSE) © Jon Bogaty.

package/SECURITY.md

@@ -0,0 +1,25 @@
+# Security Policy
+
+## Reporting a vulnerability
+
+Please do not open a public issue for a security problem.
+
+Report it privately through
+[GitHub Security Advisories](https://github.com/jbcom/koota-kit/security/advisories/new),
+which lets us discuss and fix the issue before it is disclosed.
+
+You can expect an acknowledgement within a few days. If a fix is warranted, we
+will prepare it privately, publish a patched release, and credit you in the
+advisory unless you would rather remain anonymous.
+
+## Supported versions
+
+The latest `0.x` release receives security fixes. Older pre-1.0 releases are
+not patched unless a coordinated disclosure requires an exceptional backport.
+
+## In scope
+
+Examples include malicious persisted snapshot handling, package supply-chain
+issues, unexpected code execution during install/build, and vulnerabilities in
+the package's runtime dependencies. Application authorization and game logic
+built on top of koota-kit are outside this repository's security boundary.

package/dist/cjs/eventLog.cjs

@@ -0,0 +1,81 @@
+"use strict";
+// Scratch-backed event logs — the publish/drain seam between sim systems.
+//
+// A fixed-timestep sim needs one system to tell another that something HAPPENED,
+// not merely that some state now differs. The distinction is load-bearing: a
+// system cannot infer an event from state a lower priority band has already
+// consumed, so "a demon was struck this tick" has to be published as a fact
+// rather than reconstructed from health that has already changed.
+//
+// Every such log is the same shape: an array under a well-known scratch key,
+// appended by the owner, drained by exactly one consumer. Consuming systems
+// drain (the log must empty, or a cue plays twice); OBSERVERS — a dev harness, a
+// test, a HUD — must peek instead, because a reader that consumes what a consumer
+// needs is a race, and whichever runs first wins.
+//
+// That distinction is why this is a package module rather than a snippet. It was
+// re-derived ELEVEN times in one consuming game, and three of those sites had no
+// peek at all until an observer silently stole records from the audio bridge and
+// the missing sound was misdiagnosed as a missing swing. The pattern is not hard;
+// getting it wrong is quiet, and it costs a debugging session every time.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineEventLog = defineEventLog;
+/**
+ * Declare an event log under `key`.
+ *
+ * The array is created lazily on first use and lives in `handle.scratch`, so it
+ * lifecycles with the world: a new run starts with empty logs and cannot inherit
+ * the last one's events. That is not a detail — a log at module scope survives
+ * the world that produced it, and stale events replay into a fresh run.
+ *
+ * Keys should be namespaced by system (`"combat:hits"`, `"voices:events"`) for
+ * the same reason trait names are: scratch is one flat map shared by every
+ * system in the world. Empty keys are rejected, as is a collision with an
+ * existing non-array scratch value.
+ */
+function defineEventLog(key) {
+    if (typeof key !== "string" || key.trim().length === 0) {
+        throw new TypeError("defineEventLog: key must be a non-empty string.");
+    }
+    const existingFor = (handle) => {
+        const existing = handle.scratch.get(key);
+        if (existing === undefined)
+            return undefined;
+        if (!Array.isArray(existing)) {
+            throw new TypeError(`Event log "${key}" cannot use its scratch key because it already holds a non-array value.`);
+        }
+        return existing;
+    };
+    const arrayFor = (handle) => {
+        const existing = existingFor(handle);
+        if (existing)
+            return existing;
+        const log = [];
+        handle.scratch.set(key, log);
+        return log;
+    };
+    return {
+        key,
+        push: (handle, event) => {
+            arrayFor(handle).push(event);
+        },
+        drain: (handle) => {
+            const log = existingFor(handle);
+            if (!log)
+                return [];
+            // Copy, then truncate IN PLACE rather than replacing the array: another
+            // system may already hold this reference, and swapping in a new array
+            // would leave that holder appending into an orphan nobody drains.
+            const out = log.slice();
+            log.length = 0;
+            return out;
+        },
+        peek: (handle) => existingFor(handle)?.slice() ?? [],
+        clear: (handle) => {
+            const log = existingFor(handle);
+            if (log)
+                log.length = 0;
+        },
+        size: (handle) => existingFor(handle)?.length ?? 0,
+    };
+}

package/dist/cjs/eventLog.d.cts

@@ -0,0 +1,49 @@
+import type { WorldHandle } from "./world.cjs";
+/**
+ * A published event log: append here, drain or peek from the other side.
+ *
+ * Returned as an object rather than loose functions so a system declares its log
+ * ONCE at module scope and the key is written in exactly one place. Two string
+ * literals for the same log is the typo that produces an event stream nobody
+ * receives, and no type checker can catch it.
+ */
+export type EventLog<T> = {
+    /** The scratch key, exposed for debugging and for snapshot tooling. */
+    readonly key: string;
+    /** Append an event. Called by the system that owns the fact. */
+    push: (handle: WorldHandle, event: T) => void;
+    /**
+     * Take every event and EMPTY the log — for the single consuming system.
+     *
+     * If two systems both need the same events, that is a design question and not
+     * a reason to drain twice: publish two logs, or have the second peek. A log
+     * drained by two consumers delivers each event to whichever ran first.
+     */
+    drain: (handle: WorldHandle) => T[];
+    /**
+     * Read every event WITHOUT emptying — for observers: harnesses, tests, HUDs.
+     *
+     * Returns a readonly copy, so a caller cannot mutate the live array and
+     * cannot hold a reference that changes underneath them.
+     */
+    peek: (handle: WorldHandle) => readonly T[];
+    /** Drop everything without reading. For run teardown and test setup. */
+    clear: (handle: WorldHandle) => void;
+    /** How many events are pending, without allocating a copy. */
+    size: (handle: WorldHandle) => number;
+};
+/**
+ * Declare an event log under `key`.
+ *
+ * The array is created lazily on first use and lives in `handle.scratch`, so it
+ * lifecycles with the world: a new run starts with empty logs and cannot inherit
+ * the last one's events. That is not a detail — a log at module scope survives
+ * the world that produced it, and stale events replay into a fresh run.
+ *
+ * Keys should be namespaced by system (`"combat:hits"`, `"voices:events"`) for
+ * the same reason trait names are: scratch is one flat map shared by every
+ * system in the world. Empty keys are rejected, as is a collision with an
+ * existing non-array scratch value.
+ */
+export declare function defineEventLog<T>(key: string): EventLog<T>;
+//# sourceMappingURL=eventLog.d.cts.map

package/dist/cjs/eventLog.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventLog.d.ts","sourceRoot":"","sources":["../../src/eventLog.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,uEAAuE;IACvE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC9C;;;;;;OAMG;IACH,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,CAAC,EAAE,CAAC;IACpC;;;;;OAKG;IACH,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,SAAS,CAAC,EAAE,CAAC;IAC5C,wEAAwE;IACxE,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;IACrC,8DAA8D;IAC9D,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,CAAC;CACvC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CA6C1D"}

package/dist/cjs/index.cjs

@@ -0,0 +1,36 @@
+"use strict";
+// koota-kit — thin koota ECS conventions layer.
+//
+// Four modules, also importable as subpaths:
+//   ./world    — WorldHandle lifecycle (world + dual-stream rng + clock + scratch)
+//   ./rng      — dual-layer deterministic seedrandom PRNG with byte-exact
+//                snapshot/restore
+//   ./traits   — defineTrait AoS-aliasing guard (leaf module, zero sibling
+//                imports)
+//   ./eventLog — scratch-backed publish/drain event logs with a peek seam for
+//                observers (harnesses, tests, HUDs)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTrait = exports.defineEventLog = exports.snapshotStream = exports.snapshotLayers = exports.restoreStream = exports.restoreLayers = exports.nextU32 = exports.nextInt = exports.nextFloat = exports.createRng = exports.chance = exports.trait = exports.snapshotWorld = exports.restoreWorldHeader = exports.relation = exports.destroySimWorld = exports.createSimWorld = exports.createActions = exports.advanceClock = void 0;
+var world_js_1 = require("./world.cjs");
+Object.defineProperty(exports, "advanceClock", { enumerable: true, get: function () { return world_js_1.advanceClock; } });
+Object.defineProperty(exports, "createActions", { enumerable: true, get: function () { return world_js_1.createActions; } });
+Object.defineProperty(exports, "createSimWorld", { enumerable: true, get: function () { return world_js_1.createSimWorld; } });
+Object.defineProperty(exports, "destroySimWorld", { enumerable: true, get: function () { return world_js_1.destroySimWorld; } });
+Object.defineProperty(exports, "relation", { enumerable: true, get: function () { return world_js_1.relation; } });
+Object.defineProperty(exports, "restoreWorldHeader", { enumerable: true, get: function () { return world_js_1.restoreWorldHeader; } });
+Object.defineProperty(exports, "snapshotWorld", { enumerable: true, get: function () { return world_js_1.snapshotWorld; } });
+Object.defineProperty(exports, "trait", { enumerable: true, get: function () { return world_js_1.trait; } });
+var rng_js_1 = require("./rng.cjs");
+Object.defineProperty(exports, "chance", { enumerable: true, get: function () { return rng_js_1.chance; } });
+Object.defineProperty(exports, "createRng", { enumerable: true, get: function () { return rng_js_1.createRng; } });
+Object.defineProperty(exports, "nextFloat", { enumerable: true, get: function () { return rng_js_1.nextFloat; } });
+Object.defineProperty(exports, "nextInt", { enumerable: true, get: function () { return rng_js_1.nextInt; } });
+Object.defineProperty(exports, "nextU32", { enumerable: true, get: function () { return rng_js_1.nextU32; } });
+Object.defineProperty(exports, "restoreLayers", { enumerable: true, get: function () { return rng_js_1.restoreLayers; } });
+Object.defineProperty(exports, "restoreStream", { enumerable: true, get: function () { return rng_js_1.restoreStream; } });
+Object.defineProperty(exports, "snapshotLayers", { enumerable: true, get: function () { return rng_js_1.snapshotLayers; } });
+Object.defineProperty(exports, "snapshotStream", { enumerable: true, get: function () { return rng_js_1.snapshotStream; } });
+var eventLog_js_1 = require("./eventLog.cjs");
+Object.defineProperty(exports, "defineEventLog", { enumerable: true, get: function () { return eventLog_js_1.defineEventLog; } });
+var index_js_1 = require("./traits/index.cjs");
+Object.defineProperty(exports, "defineTrait", { enumerable: true, get: function () { return index_js_1.defineTrait; } });

package/dist/cjs/index.d.cts

@@ -0,0 +1,9 @@
+export { advanceClock, createActions, createSimWorld, destroySimWorld, relation, restoreWorldHeader, snapshotWorld, trait, } from "./world.cjs";
+export type { Entity, World, WorldHandle, WorldSnapshot } from "./world.cjs";
+export { chance, createRng, nextFloat, nextInt, nextU32, restoreLayers, restoreStream, snapshotLayers, snapshotStream, } from "./rng.cjs";
+export type { RngLayers, RngLayersSnapshot, RngSeeds, RngStream, RngStreamSnapshot, } from "./rng.cjs";
+export { defineEventLog } from "./eventLog.cjs";
+export type { EventLog } from "./eventLog.cjs";
+export { defineTrait } from "./traits/index.cjs";
+export type { SafeSchema } from "./traits/index.cjs";
+//# sourceMappingURL=index.d.cts.map

package/dist/cjs/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,cAAc,EACd,eAAe,EACf,QAAQ,EACR,kBAAkB,EAClB,aAAa,EACb,KAAK,GACN,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE5E,OAAO,EACL,MAAM,EACN,SAAS,EACT,SAAS,EACT,OAAO,EACP,OAAO,EACP,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,QAAQ,EACR,SAAS,EACT,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/cjs/package.json

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