@ghostry/fabricator 0.0.1 → 0.0.3

package/dist/types/index.d.ts

@@ -1,186 +1,153 @@
 import type { Limits } from "./Enumeration/Types";
-import type { Instance } from "./Instance/Types";
-import type { Algorithm, Attribution, Seed } from "./Random/Types";
+import type { Instance, Stack } from "./Instance/Types";
+import type { Algorithm, Salt } from "./Random/Types";
 import { registry } from "./Schema/Registry";
 import type { PlainObject } from "./Utility/Types";
 export declare function initialize<const $Registry extends PlainObject = typeof registry>(config?: Partial<{
     /** The registry of type definers to use — `registry` itself. */
     types: $Registry;
     /**
-     * Optional mixer composed into every stream beside `clock`. Accepts
-     * a single string, or several — several lets a seed be composed out
-     * of independent, meaningful parts (a user id, a scenario label)
-     * without hand-joining them first. If omitted, the seed is empty
-     * (unless `FABRICATOR_SEED` / `SEED` / `RANDOM_SEED` supplies one):
-     * wall-clock `clock` is the default entropy, so an unconfigured
-     * instance varies by run and replays from `context.clock` alone.
-     * Pass a seed when two instances should share a clock but draw
-     * different universes, or when `clock: "seeded"` should make the
-     * seed itself the reproducibility unit.
+     * Optional differentiator composed into every stream beside `clock` — it
+     * distinguishes runs, it does not generate them. Accepts a single string,
+     * or several — several lets a salt be composed out of independent,
+     * meaningful parts (a user id, a scenario label) without hand-joining them
+     * first. If omitted, the salt is empty (unless `FABRICATOR_SALT` supplies
+     * one): wall-clock `clock` is the default entropy, so an unconfigured
+     * instance varies by run and replays from `context.clock` alone. Pass a
+     * salt when two instances should share a clock but draw different
+     * universes, or when `clock: "derived"` should make the salt itself the
+     * reproducibility unit.
      */
-    seed?: Seed;
+    salt?: Salt;
     /**
-     * Bring your own PRNG: a factory that, given a seed, returns a
-     * source of randomness — a `() => number` in `[0, 1)`, a drop-in
-     * for `Math.random`. Defaults to the built-in `sfc32` generator.
+     * Bring your own PRNG: a factory that, given a seed, returns a source of
+     * randomness — a `() => number` in `[0, 1)`, a drop-in for `Math.random`.
+     * The seed is a whole encoded trace, of which `salt` is one slot, not the
+     * `salt` itself. Defaults to the built-in `sfc32` generator.
      */
     algorithm?: Algorithm;
     /**
-     * How this instance attributes a construction's randomness to the
-     * file it was written in:
-     *
-     * - `{ kind: "rooted", root }` expresses every file relative to
-     *   `root` (an absolute path or a `file://` URL), so the same seed
-     *   reproduces the same data on a checkout at a different absolute
-     *   path.
-     * - `{ kind: "call site" }`, the default, is `"rooted"` at the
-     *   directory of whichever file called `initialize()`.
-     * - `{ kind: "none" }` attributes nothing: every construction of a
-     *   given kind anywhere in the instance shares one stream, keyed
-     *   by kind alone.
-     *
-     * See [Reproducibility](https://ghostry-dev.github.io/fabricator/guides/reproducibility)
-     * for the trade-offs between the three.
-     */
-    attribution?: Attribution;
-    /**
-     * Instance-wide numeric ceilings. `combinatorial` bounds how many
-     * instances `combinatorial(...)` may enumerate — the check is
-     * eager, it throws at call time before any instance is produced.
-     * Defaults to 1024 if omitted. `coverage(...)` carries no entry
-     * here: its count is the widest single axis, so there is nothing
-     * for a limit to protect against.
+     * Instance-wide numeric ceilings. `combinatorial` bounds how many instances
+     * `combinatorial(...)` may enumerate — the check is eager, it throws at
+     * call time before any instance is produced. Defaults to 1024 if omitted.
+     * `coverage(...)` carries no entry here: its count is the widest single
+     * axis, so there is nothing for a limit to protect against.
      */
     limits?: Limits;
     /**
      * What `T.date.past`/`T.date.future` (and any producer reading
-     * `ProduceContext.clock`) resolve "now" against — and, because it
-     * sits in every leaf's trace, the default entropy for the instance.
-     * Defaults to the wall-clock instant of this `initialize()` call, so
-     * an unconfigured run has realistic dates and varies by process, and
-     * replays from `context.clock` (with the same empty or supplied
-     * `seed`). Pass a fixed `Date` to freeze "now" (and the rest of the
-     * run, unless `seed` also differs). Pass `"seeded"` to derive "now"
-     * from the instance seed instead — an instant drawn across the whole
-     * representable `Date` span, so an implausible date is the expected
-     * outcome of that policy, not a bug. `"seeded"` is what makes `seed`
-     * alone the reproducibility unit.
+     * `ProduceContext.clock`) resolve "now" against — and, because it sits in
+     * every leaf's trace, the default entropy for the instance. Defaults to the
+     * wall-clock instant of this `initialize()` call, so an unconfigured run
+     * has realistic dates and varies by process, and replays from
+     * `context.clock` (with the same empty or supplied `salt`). Pass a fixed
+     * `Date` to freeze "now" (and the rest of the run, unless `salt` also
+     * differs). Pass `"derived"` to derive "now" from the instance salt instead
+     * — an instant drawn across the whole representable `Date` span, so an
+     * implausible date is the expected outcome of that policy, not a bug.
+     * `"derived"` is what makes `salt` alone the reproducibility unit.
      */
-    clock?: Date | "seeded";
+    clock?: Date | "derived";
+    /**
+     * The ambient carrier backing `wrap` for this lineage — override only to
+     * force a specific one.
+     *
+     * Left unset (the norm), the `#stack` package import picks it: every
+     * runtime with `node:async_hooks` — Node, Bun, Deno — gets the
+     * `AsyncLocalStorage` carrier, whose frames survive `await` and isolate
+     * concurrent `wrap`s; anywhere else falls back to a synchronous LIFO, on
+     * which `wrap` rejects an async block rather than silently resolving a
+     * later build against this instance. Supplying one is how a test drives the
+     * carrier it did not get by condition.
+     */
+    stack?: Stack;
 }>): Instance<$Registry>;
 export { Omitted } from "./Types";
 /**
- * Tags a `Seed` — for `new Fabricator(schema, { seed })`, or `fork`'s
- * own `Overlay.seed` — as composing onto whatever base is in effect,
- * rather than replacing it outright.
+ * Tags a `Salt` — for `new Fabricator(schema, { salt })`, or `fork`'s own
+ * `Overlay.salt` — as composing onto whatever base is in effect, rather than
+ * replacing it outright.
  */
 export { layer } from "./Random";
 /**
- * `layer(...)`'s return type, so a caller building one programmatically
- * can name it — the same rationale as the existing `Seed`/`Attribution`
- * exports.
+ * `layer(...)`'s return type, so a caller building one programmatically can
+ * name it — the same rationale as the existing `Salt` export.
  */
 export type { Layered } from "./Random/Types";
 /**
  * Every failure this library raises is an instance of this class — see
- * `src/Error/index.ts` for the full hierarchy. Only the base is
- * public; subclasses are distinguished by `.name`.
+ * `src/Error/index.ts` for the full hierarchy. Only the base is public;
+ * subclasses are distinguished by `.name`.
  */
 export { FabricatorError } from "./Error";
 /**
- * The adapter contract, exported because an adapter is a separate
- * package rather than something registered here: `Adapter`/`Recurse`
- * are what one declares, `drive` is what its conversion entry point
- * calls, and `Adaptation`/`AdaptationsOf` are how it reads what a
- * Schema declared — `[Adaptation]` at runtime, `AdaptationsOf` at the
- * type level, keyed by its own `key` in both cases.
- *
- * This package names no external schema library and depends on none:
- * every mapping, and every dependency it needs, belongs to the
- * adapter.
- *
- * `Adapting` is the odd one out, facing whoever *writes* an adaptation
- * rather than whoever implements an adapter: it is the parameter type
- * of every kind's `.adapt(adapter, produce)` producer, so a caller
- * writing that producer as a named function can name it — the same
- * reason `Stream` is exported below.
- */
-export { drive } from "./Adapter/Core";
-export type { Adaptations, AdaptationsOf, Adapter, Adapting, Recurse, } from "./Adapter/Types";
-export { Adaptation } from "./Types";
-/**
- * The default registry of type definers, exported so it can be
- * extended via `registry.extend(({ T }) => ({ ... }))` before being
- * passed to `initialize({ types })`.
+ * The default registry of type definers, exported so it can be extended via
+ * `registry.extend(({ T }) => ({ ... }))` before being passed to `initialize({
+ * types })`.
  */
 export { registry } from "./Schema/Registry";
 /**
- * Canonical `{ value, exclusive }` endpoint stored on `whereby` min/max,
- * plus the call-site union that still accepts a scalar (inclusive). Exported
- * so a named `.whereby(...)` argument or an `.adapt` producer reading `meta`
- * can type it — the same rationale as `Stream`.
+ * Canonical `{ value, exclusive }` endpoint stored on `whereby` min/max, plus
+ * the call-site union that still accepts a scalar (inclusive). Exported so a
+ * named `.whereby(...)` argument or an `.adapt` producer reading `meta` can
+ * type it — the same rationale as `Stream`.
  */
+export { effectiveDiscrete, toBound } from "./Bound";
 export type { Bound, InputBound } from "./Bound";
-export { toBound, effectiveDiscrete } from "./Bound";
 /**
- * Public because it is the type of `ProduceContext`'s `random` member
- * — the seeded stream every kind's `.as(produce)` and `T.opaque`'s
- * producer are handed — so a caller writing either as a named function
- * can name it.
+ * Public because it is the type of `ProduceContext`'s `random` member — the
+ * seeded stream every kind's `.as(produce)` and `T.opaque`'s producer are
+ * handed — so a caller writing either as a named function can name it.
  */
 export type { Stream } from "./Random/Types";
 /**
- * What every kind's `.as(produce)` producer is called with — a single
- * curated object rather than a positional argument list, so a caller
- * writing the producer as a named function can name its parameter.
- * `T.opaque`'s producer takes the same shape.
+ * What every kind's `.as(produce)` producer is called with — a single curated
+ * object rather than a positional argument list, so a caller writing the
+ * producer as a named function can name its parameter. `T.opaque`'s producer
+ * takes the same shape.
  */
 export type { ProduceContext } from "./Random/Types";
 /**
- * The shape `initialize({ seed })` and `new Fabricator(schema, { seed })`
- * both accept — a single string, or several — so a caller building one
- * programmatically (rather than as an inline literal) can name the
- * type.
+ * What every kind's `.adapt(adapter, produce)` producer is called with — `{
+ * schema, meta }` — the same rationale as `Stream`/`ProduceContext` above: a
+ * caller writing the producer as a named function can name its parameter.
+ * `meta` is the kind's own config, reachable here without importing the `Meta`
+ * well-known symbol from `@ghostry/fabricator/internal` — that symbol stays off
+ * the path an ordinary caller writing an `.adapt()` call has to walk. The rest
+ * of the adapter contract (`walk`, `Adapter`, `Adaptation`, `Adaptations`,
+ * `AdaptationsOf`, `Recurse`) is exported from `@ghostry/fabricator/adapting`
+ * instead — surface for implementing an adapter, not for calling `.adapt()`.
  */
-export type { Seed } from "./Random/Types";
+export type { Adapting } from "./Adapter/Types";
 /**
- * The shape `initialize({ attribution })` accepts, so a caller building
- * one programmatically — a rooted policy derived from an env var, say
- * — can name the type.
+ * The shape `initialize({ salt })` and `new Fabricator(schema, { salt })` both
+ * accept — a single string, or several — so a caller building one
+ * programmatically (rather than as an inline literal) can name the type.
  */
-export type { Attribution } from "./Random/Types";
+export type { Salt } from "./Random/Types";
 /**
- * Reads the value type a built Fabricator produces straight off its
- * `fabricate` signature — `Fabrication<typeof Product>` instead of
- * `ReturnType<typeof Product.fabricate>`.
+ * Reads the value type a built Fabricator produces straight off its `fabricate`
+ * signature — `Fabrication<typeof Product>` instead of `ReturnType<typeof
+ * Product.fabricate>`.
  */
 export type { Fabrication } from "./Fabricator/Types";
 /**
- * Reads the value type a Schema (not yet built) will eventually
- * produce, via its phantom `[Produces]` marker. Mostly useful for a
- * helper that accepts a Schema before it's built into a Fabricator.
+ * Reads the value type a Schema (not yet built) will eventually produce, via
+ * its phantom `[Produces]` marker. Mostly useful for a helper that accepts a
+ * Schema before it's built into a Fabricator.
  */
 export type { ValueOf } from "./Schema/Types";
 /**
- * `fabricator.trace`'s type — otherwise unnameable by a caller
- * wanting to hold onto one, the same reason `Stream` is exported
- * above.
+ * `fabricator.trace`'s type — otherwise unnameable by a caller wanting to hold
+ * onto one, the same reason `Stream` is exported above.
  */
 export type { Trace } from "./Random/Types";
-/**
- * How `file` and `ordinal` on a {@link Trace} were resolved — recorded
- * so a captured trace is self-describing, including `"counted"`
- * (replayed for a node taken from inside a `T.recursive` expansion;
- * not a variant you choose when building).
- */
-export type { RootKind } from "./Random/Types";
 /**
  * `fork`/`wrap`'s own config shapes, so a caller building an overlay
- * programmatically (rather than as an inline literal) can name them —
- * the same rationale as the existing `Seed`/`Attribution` exports.
- * `Config` is what `initialize`'s own parameter is a `Partial` of;
- * `Overlay` is what `fork`/`wrap` accept; `Context` is
- * `instance.context`'s own type, so a caller writing a helper that
+ * programmatically (rather than as an inline literal) can name them — the same
+ * rationale as the existing `Salt` export. `Config` is what `initialize`'s own
+ * parameter is a `Partial` of; `Overlay` is what `fork`/`wrap` accept;
+ * `Context` is `instance.context`'s own type, so a caller writing a helper that
  * reads it can name the parameter.
  */
-export type { Config, Context, Overlay } from "./Instance/Types";
+export type { Config, Context, Overlay, Stack } from "./Instance/Types";

package/dist/types/internal.d.ts

@@ -1,64 +1,77 @@
 /**
  * The "adapter-authoring SDK" entry point — published as the
- * `@ghostry/fabricator/internal` package export, deliberately *not*
- * re-exported from `./index.ts`. An external adapter package (e.g.
- * `@ghostry/fabricator-adapter-typebox-v0`) needs to walk a Schema/
- * Fabricator structurally and dispatch on each primitive kind's `Core`
- * shape — see "Match `Core`, never `Schema`, in a dispatch" — which
- * the end-user-facing `.` export has no reason to carry.
+ * `@ghostry/fabricator/internal` package export, deliberately _not_ re-exported
+ * from `./index.ts`. An external adapter package (e.g.
+ * `@ghostry/fabricator-adapter-typebox-v0`) needs to walk a Schema/ Fabricator
+ * structurally and dispatch on each primitive kind's `Core` shape — see "Match
+ * `Core`, never `Schema`, in a dispatch" — which the end-user-facing `.` export
+ * has no reason to carry.
  *
- * Also this package's own white-box test suite's route to source: a
- * test file imports through `@ghostry/fabricator`/
- * `@ghostry/fabricator/internal` rather than a relative `../src/...`
- * path specifically so it resolves through the built `dist/` (see the
- * "Random", "Schema", and "Enumeration" groups below) — the same
- * reason an adapter needs this entry point, applied to this package's
+ * Also this package's own white-box test suite's route to source: a test file
+ * imports through `@ghostry/fabricator`/ `@ghostry/fabricator/internal` rather
+ * than a relative `../src/...` path specifically so it resolves through the
+ * built `dist/` (see the "Random", "Schema", and "Enumeration" groups below) —
+ * the same reason an adapter needs this entry point, applied to this package's
  * own tests instead of an external one.
  *
- * Everything here is curated, not incidental. When wiring a new leaf
- * kind into the rest of the system, add its module to
- * `Primitive/namespace.ts` (re-exported here as `Primitive`), or no
- * adapter can reach that kind's `Core` type.
+ * Everything here is curated, not incidental. When wiring a new leaf kind into
+ * the rest of the system, add its module to `Primitive/namespace.ts`
+ * (re-exported here as `Primitive`), or no adapter can reach that kind's `Core`
+ * type.
  */
 export type { Fabrication, NaiveFabricator } from "./Fabricator/Types";
+/**
+ * Schema -> the Fabricator type `construct()` produces for it, dispatching per
+ * kind. `Constructor` already names this as its own construct signature's
+ * return, but only _inside_ a generic call: a wrapping library that hands a
+ * built Fabricator to its own callers has to name the type without making that
+ * call, and cannot infer it back out of `Constructor` because the signature is
+ * generic (a `Constructor extends { new (schema: $S, ...): infer $R }` match
+ * instantiates at the constraint, not at `$S`).
+ *
+ * `@ghostry/extern-extension-fabricator-v0` is the case in point: it hands the
+ * built Fabricator to a user callback as the shaping handle, so the handle's
+ * type is exactly this. Without it, an integration is pushed into hand-writing
+ * a per-kind stand-in — a second copy of this mapping, susceptible to drift.
+ */
+export type { AsFabricator } from "./Fabricator/Types";
 export { Children, Kind, Meta, Produces, type Buildable } from "./Types";
 export { isPlainObject } from "./Utility/Core";
 export type * as Primitive from "./Primitive/namespace";
 /**
- * `Schema/Types.ts`'s own value-type resolution, needed by tests
- * asserting `ValueOf<...>` directly rather than through a built
- * Fabricator's `Fabrication<...>`.
+ * `Schema/Types.ts`'s own value-type resolution, needed by tests asserting
+ * `ValueOf<...>` directly rather than through a built Fabricator's
+ * `Fabrication<...>`.
  */
 export type { ValueOf } from "./Schema/Types";
 /**
- * `Constructor` is `Instance.Fabricator`'s own type — public in effect
- * (every `initialize()` caller receives one), just never named
- * directly by the `.` export, which only ever describes it inline.
+ * `Constructor` is `Instance.Fabricator`'s own type — public in effect (every
+ * `initialize()` caller receives one), just never named directly by the `.`
+ * export, which only ever describes it inline.
  */
 export type { Constructor } from "./Fabricator/Constructor";
 /**
- * The enumeration planner's own shapes — `combinatorial`/`coverage`
- * (the `.` export's public entry points) are built on `plan`/`resolve`,
- * which a test asserting `axisFor`'s per-kind width/strategy decisions
- * needs directly.
+ * The enumeration planner's own shapes — `combinatorial`/`coverage` (the `.`
+ * export's public entry points) are built on `plan`/`resolve`, which a test
+ * asserting `axisFor`'s per-kind width/strategy decisions needs directly.
  */
 export { plan, resolve } from "./Enumeration/Plan";
 export type { Axis, Enumerable, Pin, Resolvable } from "./Enumeration/Types";
 /**
- * The randomness layer underneath
- * `initialize({ seed, algorithm, attribution })` and a Fabricator's
- * `.trace` — needed by tests exercising stream attribution and
- * construction directly, beneath the level `initialize()` itself
- * exposes.
+ * The randomness layer underneath `initialize({ clock, salt, algorithm })` and
+ * a Fabricator's `.trace` — needed by tests exercising stream construction
+ * directly, beneath the level `initialize()` itself exposes.
  */
-export { defaultAlgorithm, encode, randomSeed, toRandomSource, toStream, toStreamFromTrace, } from "./Random";
-export type { Algorithm, ConstructionTrace, ConstructorOptions, ResolvedAttribution, RootKind, RootPins, Seed, Trace, } from "./Random/Types";
+export { defaultAlgorithm, encode, randomSalt, toRandomSource, toStream, toStreamFromTrace, } from "./Random";
+export type { Algorithm, ConstructionTrace, ConstructorOptions, RootPins, Salt, Trace, } from "./Random/Types";
 /**
- * `Random/CallSite.ts`'s pure string helpers. Exported for this
- * package's own tests: the percent-encoded, `file://`-prefixed, and
- * backslashed spellings they exist to fold together cannot be produced
- * by running the suite from an ordinary POSIX checkout, so they have
- * to be driven with synthetic frame strings instead of real stack
- * frames.
+ * The synchronous ambient carrier. `#stack` (`package.json`) selects it only
+ * where there is no `node:async_hooks` — in practice a browser bundle — so on
+ * Bun, Node, and Deno alike the condition always resolves to the
+ * `AsyncLocalStorage` one instead. Exported for this package's own tests:
+ * without it, neither the synchronous carrier's behavior nor `wrap`'s rejection
+ * of an async block under it is reachable from the suite. It is also a
+ * serviceable argument for `initialize({ stack })` for anyone who wants the old
+ * semantics back deliberately.
  */
-export { directoryOf, normalizeLocation, relativize } from "./Random/CallSite";
+export { toStack as toSynchronousStack } from "./Instance/Stack/Sync";

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "@ghostry/fabricator",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "description": "Fabricate typed data from composable schemas.",
   "keywords": [
-    "factory"
+    "factory",
+    "reproducible",
+    "fixtures",
+    "testing",
+    "mock",
+    "schema",
+    "typescript"
   ],
   "author": {
     "name": "Patrick Rebsch"
@@ -14,11 +20,24 @@
     "url": "git+https://github.com/ghostry-dev/fabricator",
     "directory": "pkg/fabricator"
   },
-  "homepage": "https://github.com/ghostry-dev/fabricator",
+  "homepage": "https://docs.ghostry.dev/fabricator/",
   "bugs": "https://github.com/ghostry-dev/fabricator/issues",
   "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "types": "./dist/types/index.d.ts",
   "module": "./dist/esm/index.js",
+  "imports": {
+    "#stack": {
+      "types": "./src/Instance/Stack/Async.ts",
+      "deno": "./src/Instance/Stack/Async.ts",
+      "node": "./dist/esm/Instance/Stack/Async.js",
+      "bun": "./dist/esm/Instance/Stack/Async.js",
+      "default": "./dist/esm/Instance/Stack/Sync.js"
+    }
+  },
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -29,6 +48,16 @@
       "types": "./dist/types/internal.d.ts",
       "import": "./dist/esm/internal.js",
       "default": "./dist/esm/internal.js"
+    },
+    "./adapting": {
+      "types": "./dist/types/adapting.d.ts",
+      "import": "./dist/esm/adapting.js",
+      "default": "./dist/esm/adapting.js"
+    },
+    "./harnessing": {
+      "types": "./dist/types/harnessing.d.ts",
+      "import": "./dist/esm/harnessing.js",
+      "default": "./dist/esm/harnessing.js"
     }
   },
   "publishConfig": {
@@ -39,13 +68,16 @@
     "build:reset": "rm -rf ./dist",
     "build:compile": "bunx --no-install --bun rslib build --config ./rslib.config.ts",
     "build:compile:rsdoctor": "RSDOCTOR=true bunx --no-install --bun rslib build --config ./rslib.config.ts",
+    "build:types": "bun --bun ../../node_modules/typescript-5/lib/tsc.js -p ./tsconfig.build.json --noEmit false --declaration --emitDeclarationOnly --declarationDir ./dist/types",
+    "build:verify": "tsc --noEmit -p ./tsconfig.verify.json",
     "build:clean": "find ./dist -type f -name '*.tsbuildinfo' -delete",
-    "build": "bun run build:reset && bun run build:compile && bun run build:clean",
-    "build:rsdoctor": "bun run build:reset && bun run build:compile:rsdoctor && bun run build:clean",
+    "build": "bun run build:reset && bun run build:compile && bun run build:types && bun run build:verify && bun run build:clean",
+    "build:rsdoctor": "bun run build:reset && bun run build:compile:rsdoctor && bun run build:types && bun run build:verify && bun run build:clean",
     "check": "tsc --noEmit",
     "check:ts5": "bun --bun ../../node_modules/typescript-5/lib/tsc.js --noEmit",
-    "prettier": "bunx --no-install --bun prettier .",
-    "test": "bun run check && bun run check:ts5 && bun test"
+    "check:jsr": "DENO_BIN_PATH=$PWD/../../node_modules/.bin/deno bunx --no-install jsr publish --dry-run --allow-dirty",
+    "format": "bunx --no-install oxfmt .",
+    "test": "bun run check && bun run check:ts5 && bun run check:jsr && bun test"
   },
   "files": [
     "dist"

package/dist/esm/Random/CallSite.js

@@ -1,56 +0,0 @@
-const OWN_ROOT = normalizeLocation(new URL("..", import.meta.url).href);
-function stripPosition(text) {
-    return text.replace(/:\d+:\d+/g, "");
-}
-function extractLocation(frameLine) {
-    const trimmed = frameLine.trim().replace(/^at\s+/, "");
-    const parenthesized = trimmed.match(/\(([^()]*)\)$/);
-    return parenthesized ? parenthesized[1] : trimmed;
-}
-function decode(text) {
-    try {
-        return decodeURIComponent(text);
-    } catch  {
-        return text;
-    }
-}
-function normalizeLocation(location) {
-    const isUrl = location.startsWith("file://");
-    const path = isUrl ? decode(location.slice(7)) : location;
-    return path.replace(/\\/g, "/").replace(/^\/?([A-Za-z]):\//, (_, letter)=>`/${letter.toUpperCase()}:/`);
-}
-function directoryOf(location) {
-    const cut = location.lastIndexOf("/");
-    return -1 === cut ? location : location.slice(0, cut + 1);
-}
-function relativize(root, file) {
-    if (!file.startsWith("/")) return file;
-    const from = root.split("/").filter(Boolean);
-    const to = file.split("/").filter(Boolean);
-    let shared = 0;
-    while(shared < from.length && shared < to.length && from[shared] === to[shared])shared++;
-    const traversals = Array(from.length - shared).fill("..");
-    return [
-        ...traversals,
-        ...to.slice(shared)
-    ].join("/");
-}
-function isOwnFrame(location) {
-    return location.startsWith(OWN_ROOT);
-}
-function firstExternalFrame(stack) {
-    var _ref, _locations_find;
-    const locations = stack.split("\n").filter((line)=>line.trim().startsWith("at ")).map(extractLocation).map(normalizeLocation);
-    return null != (_ref = null != (_locations_find = locations.find((location)=>!isOwnFrame(location))) ? _locations_find : locations[locations.length - 1]) ? _ref : stack;
-}
-function resolveCallerFile() {
-    var _stack;
-    if ("function" == typeof Error.captureStackTrace) {
-        var _captured_stack;
-        const captured = {};
-        Error.captureStackTrace(captured);
-        return stripPosition(firstExternalFrame(null != (_captured_stack = captured.stack) ? _captured_stack : ""));
-    }
-    return stripPosition(null != (_stack = new Error().stack) ? _stack : "");
-}
-export { directoryOf, normalizeLocation, relativize, resolveCallerFile };

package/dist/types/Random/CallSite.d.ts

@@ -1,59 +0,0 @@
-/**
- * One canonical form for a location, whatever produced it: Node ESM
- * emits `file:///…` URLs, Bun emits bare absolute paths, and this
- * module's own `import.meta.url` is percent-encoded — three spellings
- * of one file that must compare equal, or `isOwnFrame`/`relativize`
- * silently stop matching. A bare path is trusted as-is and never
- * decoded, since it may contain a literal `%20`; only the `file://`
- * form's escaping is guaranteed well-formed. Forward slashes and an
- * uppercased leading `/X:/` drive fold Windows' `C:\a\b` and
- * `file:///c:/a/b` together — the drive is the one component two
- * sources disagree on, so it's the only thing case-folded: doing more
- * would break case-sensitive filesystems and change what ends up
- * hashed.
- */
-export declare function normalizeLocation(location: string): string;
-/**
- * The directory a location sits in, trailing separator included —
- * without it, a root of `/a/b/` would match the unrelated sibling
- * `/a/bcd/x.ts`, since `startsWith`/prefix-stripping only sees
- * character runs, not path segments.
- */
-export declare function directoryOf(location: string): string;
-/**
- * `file` expressed relative to `root`, ascending with `..` where `file`
- * sits outside `root` rather than falling back to `file` unchanged. An
- * ascending path stays identical across machines whose checkouts hold
- * both locations at the same relative position, the common case for
- * anything under the same repository — passing an escaping file through
- * as absolute would defeat the default `"call site"` policy for every
- * schema helper that isn't a sibling of wherever `initialize()` was
- * called. A location that isn't an absolute path (`native`,
- * `<anonymous>`, or a value that has already been relativized) doesn't
- * start with `/` and is returned unchanged — applying this twice is a
- * no-op, which lets `T.recursive` thread an already-relativized file
- * back through here uniformly.
- */
-export declare function relativize(root: string, file: string): string;
-/**
- * Resolve the file that (transitively) triggered the current call, so
- * construction can be attributed to the source file the user wrote it
- * in.
- *
- * Primary path: `Error.captureStackTrace` (V8, and Bun for Node
- * compatibility) captures the full stack, then `firstExternalFrame`
- * skips this library's own frames by path — no need to hardcode how
- * many frames to exclude, so it stays correct as internal call depth
- * changes.
- *
- * Fallback: engines without `captureStackTrace` get the whole raw
- * stack, position-stripped, hashed as-is rather than guessing which
- * frame to isolate. Lower fidelity (sensitive to edits anywhere in the
- * visible call chain, not just the immediate caller), but rarely
- * exercised — Bun, Node, and Chrome all support the primary path. Left
- * unnormalized: a whole multi-line stack has no single location for
- * `normalizeLocation`'s separator/drive rewriting to apply to, so this
- * path never relativizes — it always falls through `relativize`'s
- * non-absolute passthrough instead.
- */
-export declare function resolveCallerFile(): string;