foottrace 1.1.0 → 1.3.0

package/dist/types/lib/cause/recordTypes.d.ts

@@ -0,0 +1,67 @@
+import type { ControlDependency } from '../memory/backtrack.js';
+import type { LogAddress } from '../memory/eventPosition.js';
+import type { CommitBundle } from '../memory/types.js';
+import type { Adjacency, Attention, CauseGraph, Gap, GraphContext, NodeId } from './types.js';
+/** Explicit complete maps record absence too; an omitted map means it was not collected. */
+export interface RecordScope {
+    readonly address: LogAddress;
+    readonly commitLog: readonly unknown[];
+    readonly reads?: Readonly<Record<string, readonly string[]>>;
+    readonly controlDeps?: Readonly<Record<string, {
+        readonly deciderId: string;
+    }>>;
+    readonly attention?: Readonly<Record<string, readonly Attention[]>>;
+    readonly complete?: boolean;
+}
+export interface RecordNode {
+    readonly runtimeStageId: string;
+    readonly commitIdx?: number;
+    readonly key?: string;
+}
+export interface RecordGraphOptions {
+    readonly maxCommits?: number;
+    readonly maxFields?: number;
+    readonly maxEdges?: number;
+    readonly maxScopes?: number;
+    readonly loadTimeoutMs?: number;
+}
+export interface RecordCauseGraph extends CauseGraph {
+    nodeId(address: LogAddress, node: RecordNode): NodeId;
+    /** Rejects with fixed message/code on discovery failure; never reports an unavailable scope as empty. */
+    openScope(address: LogAddress, context: GraphContext): Promise<readonly NodeId[]>;
+}
+export interface RecordLoaderResult {
+    readonly scope: RecordScope;
+    readonly gaps?: readonly Gap['code'][];
+}
+export interface RecordIdentity extends RecordNode {
+    readonly address: LogAddress;
+    readonly read?: true;
+}
+export interface PreparedRecordScope {
+    address: LogAddress;
+    log: CommitBundle[];
+    reads?: Map<string, string[]>;
+    control?: Map<string, ControlDependency>;
+    marks?: Map<string, readonly Attention[]>;
+    complete: boolean;
+}
+export interface RecordLoadFailure {
+    failure: Gap['code'];
+}
+export type LoadedRecordScope = PreparedRecordScope | RecordLoadFailure;
+export interface ResolvedRecordNode {
+    scope: PreparedRecordScope;
+    identity: RecordIdentity;
+    commitIndex: number;
+}
+export interface RecordInspection {
+    adjacency: Adjacency;
+    gaps: readonly Gap[];
+}
+export type RecordScopeHost = (address: LogAddress, context: GraphContext) => RecordLoaderResult | Promise<RecordLoaderResult>;
+export interface RecordScopeLoader {
+    loadScope(address: LogAddress, context: GraphContext): Promise<LoadedRecordScope>;
+    extraGapCodes(scope: PreparedRecordScope): readonly Gap['code'][] | undefined;
+}
+export type AddRecordGap = (code: Gap['code']) => void;

package/dist/types/lib/cause/recordValidation.d.ts

@@ -0,0 +1,33 @@
+/** Admission before the existing readers touch untrusted record fields. Payloads never leave this module's graph. */
+import type { LogAddress } from '../memory/eventPosition.js';
+import type { CommitBundle } from '../memory/types.js';
+import type { GapCode } from './types.js';
+import { attention as marksOf } from './validation.js';
+import { EvidenceRefusal } from '../evidence/admission.js';
+export { marksOf };
+/** Loader refusals stay distinct from graph-port refusals so a failed host load keeps its original classification. */
+export declare class RecordRefusal extends EvidenceRefusal {
+    readonly code: GapCode;
+    constructor(code?: GapCode);
+}
+export declare function recordOwn(value: unknown, key: string): unknown;
+export declare function names(value: unknown, maximum?: number, path?: boolean): string[];
+export declare function recordName(value: unknown, path?: boolean): string;
+export declare function recordList(value: unknown, maximum: number): readonly unknown[];
+export declare function addressOf(value: unknown): LogAddress;
+export declare function spend(budget: {
+    left: number;
+}, count: number): void;
+export declare const addressKey: (a: LogAddress) => string;
+/** Iterative bounded copy: data descriptors only, no getters/toJSON/prototypes or opaque class instances. */
+export declare function dataCopy(value: unknown, budget: {
+    left: number;
+}): unknown;
+export declare function bundleOf(value: unknown, idx: number, budget: {
+    left: number;
+}): CommitBundle;
+export declare function mapOf<T>(value: unknown, limit: number, read: (v: unknown) => T, budget?: {
+    left: number;
+}): Map<string, T> | undefined;
+/** Observe native promises by intrinsic without assimilating a data object's then accessor. */
+export declare function projectLoaded<T, R>(work: () => T | Promise<T>, project: (value: T) => R): Promise<R>;

package/dist/types/lib/cause/session.d.ts

@@ -0,0 +1,30 @@
+import type { CauseGraph, ExplainOptions, Gap, GraphContext, NodeId, WalkLimits } from './types.js';
+export interface Read<T> {
+    readonly value?: T;
+    readonly gap?: Gap;
+}
+type Method = 'parents' | 'children' | 'attention' | 'gaps' | 'roots';
+/** One deadline, memo table and work budget per public query, never per graph or store. */
+export declare class Session {
+    readonly limits: Required<WalkLimits>;
+    readonly context: GraphContext;
+    readonly nodes: Set<string>;
+    readonly controller: AbortController;
+    private readonly cache;
+    private calls;
+    edges: number;
+    private timedOut;
+    private readonly deadline;
+    private readonly timer;
+    private readonly external?;
+    private readonly onAbort;
+    private readonly methods;
+    constructor(graph: CauseGraph, options?: ExplainOptions);
+    dispose(): void;
+    stopGap(id?: NodeId): Gap | undefined;
+    admit(id: NodeId): Gap | undefined;
+    hasRoots(): boolean;
+    read<T>(method: Method, id: NodeId | undefined, project: (raw: unknown) => T): Promise<Read<T>>;
+    invoke<T>(id: NodeId | undefined, work: () => unknown, project: (raw: unknown) => T): Promise<Read<T>>;
+}
+export {};

package/dist/types/lib/cause/storedRecordAdapter.d.ts

@@ -0,0 +1,11 @@
+import type { LogAddress } from '../memory/eventPosition.js';
+import { type RecordCauseGraph, type RecordGraphOptions, type RecordScope } from './recordAdapter.js';
+import type { GraphContext, MaybePromise } from './types.js';
+export interface StoredRecordScope extends Omit<RecordScope, 'address' | 'commitLog' | 'complete'> {
+    readonly entries: readonly unknown[];
+}
+export interface StoredRecordHost {
+    loadLog(address: LogAddress, context: GraphContext): MaybePromise<StoredRecordScope>;
+}
+/** Load one address only. The host owns auth/storage; cancellation is forwarded and waiting is independently bounded. */
+export declare function createStoredRecordGraph(host: StoredRecordHost, options?: RecordGraphOptions): RecordCauseGraph;

package/dist/types/lib/cause/strategies.d.ts

@@ -0,0 +1,3 @@
+import type { NodeId, RootStrategy } from './types.js';
+export declare const largestDrop: (scores: ReadonlyMap<NodeId, number>) => RootStrategy;
+export declare const mostAffected: (counts: ReadonlyMap<NodeId, number>) => RootStrategy;

package/dist/types/lib/cause/types.d.ts

@@ -0,0 +1,91 @@
+import type { GapCode } from '../evidence/codes.js';
+export type { GapCode } from '../evidence/codes.js';
+/** Names and evidence references only. No state values, messages, credentials or business payloads. */
+export type NodeId = string;
+export type AttentionKind = 'error' | 'unknown-effect' | 'gave-up' | 'timeout' | 'retried' | 'quality-drop' | 'not-collected' | 'outlier' | (string & {});
+export type AttentionReason = 'ERROR_RECORDED' | 'UNKNOWN_EFFECT_RECORDED' | 'RETRY_STOP_RECORDED' | 'TIMEOUT_RECORDED' | 'RETRY_RECORDED' | 'QUALITY_DROP_RECORDED' | 'EVIDENCE_NOT_COLLECTED' | 'OUTLIER_RECORDED' | 'BUSINESS_RULE_MATCHED';
+export interface Attention {
+    readonly kind: AttentionKind;
+    readonly reason: AttentionReason;
+    readonly evidence: readonly string[];
+}
+export type Confidence = 'complete' | 'incomplete';
+export interface Gap {
+    readonly code: GapCode;
+    readonly nodeId?: NodeId;
+    readonly evidence: readonly string[];
+}
+export interface GraphEdge {
+    readonly nodeId: NodeId;
+    readonly kind: 'data' | 'control';
+    readonly attribution: 'per-write' | 'stage' | 'recorded-control';
+    readonly evidence: readonly string[];
+}
+export interface Adjacency {
+    readonly edges: readonly GraphEdge[];
+    readonly complete: boolean;
+}
+export interface GraphContext {
+    readonly signal: AbortSignal;
+}
+export type MaybePromise<T> = T | Promise<T>;
+/** A host owns storage, authentication and service resolution. A node may represent a key-qualified write. */
+export interface CauseGraph {
+    parents(id: NodeId, context: GraphContext): MaybePromise<Adjacency>;
+    children(id: NodeId, context: GraphContext): MaybePromise<Adjacency>;
+    attention(id: NodeId, context: GraphContext): MaybePromise<readonly Attention[]>;
+    gaps(id: NodeId, context: GraphContext): MaybePromise<readonly Gap[]>;
+    /** Optional, bounded discovery seeds; attentionList can instead receive explicit nodeIds. */
+    roots?(context: GraphContext): MaybePromise<readonly NodeId[]>;
+}
+export interface TraversedEdge extends Omit<GraphEdge, 'nodeId'> {
+    readonly from: NodeId;
+    readonly to: NodeId;
+}
+export interface MarkedNode {
+    readonly nodeId: NodeId;
+    readonly attention: readonly Attention[];
+}
+export interface ImpactResult {
+    readonly nodes: readonly NodeId[];
+    readonly edges: readonly TraversedEdge[];
+    readonly confidence: Confidence;
+    readonly gaps: readonly Gap[];
+}
+export interface CauseResult {
+    readonly nodeId: NodeId;
+    readonly attention: readonly Attention[];
+    /** Present only for one supported candidate and complete backward coverage. Not provider-internal proof. */
+    readonly rootCause?: NodeId;
+    /** Selected node → candidate, following recorded dependency edges. */
+    readonly path: readonly NodeId[];
+    readonly alternatives: readonly NodeId[];
+    readonly impact: ImpactResult;
+    readonly confidence: Confidence;
+    readonly gaps: readonly Gap[];
+}
+export interface AttentionListResult {
+    readonly nodes: readonly MarkedNode[];
+    readonly confidence: Confidence;
+    readonly gaps: readonly Gap[];
+}
+export interface WalkLimits {
+    readonly maxNodes?: number;
+    readonly maxDepth?: number;
+    readonly maxEdges?: number;
+    readonly maxCalls?: number;
+    readonly timeoutMs?: number;
+}
+/** A strategy selects a tied best tier of already recorded marked nodes; it cannot introduce identities. */
+export type RootStrategy = (candidates: readonly MarkedNode[], context: GraphContext) => MaybePromise<readonly NodeId[]>;
+/** Reorder all already discovered impact references; never inject or drop evidence. */
+export type ImpactStrategy = (nodes: readonly NodeId[], context: GraphContext) => MaybePromise<readonly NodeId[]>;
+export interface ExplainOptions extends WalkLimits {
+    readonly signal?: AbortSignal;
+    readonly rankRoots?: RootStrategy;
+    readonly rankImpact?: ImpactStrategy;
+}
+export interface AttentionListOptions extends WalkLimits {
+    readonly signal?: AbortSignal;
+    readonly nodeIds?: readonly NodeId[];
+}

package/dist/types/lib/cause/validation.d.ts

@@ -0,0 +1,24 @@
+import type { Adjacency, Attention, Gap, GapCode, NodeId } from './types.js';
+import { EvidenceRefusal } from '../evidence/admission.js';
+/** Graph-port refusals carry their code through Session; loader refusals are handled at the record boundary. */
+export declare class AdmissionError extends EvidenceRefusal {
+    readonly code: GapCode;
+    constructor(code?: GapCode);
+}
+/**
+ * Only ordinary native promise wrappers belong to the async host contract.
+ * An own constructor could run an accessor/species during intrinsic then().
+ * Exotic wrappers remain the trusted host's responsibility, including rejection handling.
+ */
+export declare function observePromise(raw: unknown, accept: (raw: unknown) => void, reject: (reason: unknown) => void): boolean;
+export declare function graphOwn(value: unknown, key: string): unknown;
+export declare function plain(value: unknown): void;
+export declare function graphName(value: unknown, maximum?: number): string;
+export declare function graphList<T>(value: unknown, maximum: number, read: (item: unknown) => T, overflow?: GapCode): readonly T[];
+export declare const refs: (value: unknown) => readonly string[];
+export declare function attention(value: unknown): readonly Attention[];
+export declare function gaps(value: unknown): readonly Gap[];
+export declare function adjacency(value: unknown, maximum: number): Adjacency;
+export declare const nodeIds: (value: unknown, max: number) => readonly NodeId[];
+export declare const gap: (code: GapCode, nodeId?: NodeId) => Gap;
+export declare function uniqueGaps(items: readonly Gap[]): readonly Gap[];

package/dist/types/lib/cause/walk.d.ts

@@ -0,0 +1,12 @@
+import type { Gap, MarkedNode, NodeId, TraversedEdge } from './types.js';
+import { Session } from './session.js';
+export interface Walk {
+    readonly nodes: readonly NodeId[];
+    readonly marked: readonly MarkedNode[];
+    readonly edges: readonly TraversedEdge[];
+    readonly gaps: readonly Gap[];
+}
+/** BFS discovers the shallowest arrival; a repeated diamond node is not a cycle. */
+export declare function walk(session: Session, seeds: readonly NodeId[], direction: 'parents' | 'children'): Promise<Walk>;
+export declare function frontier(result: Walk): readonly MarkedNode[];
+export declare function pathTo(edges: readonly TraversedEdge[], start: NodeId, target: NodeId): readonly NodeId[];

package/dist/types/lib/evidence/admission.d.ts

@@ -0,0 +1,31 @@
+import type { GapCode } from './codes.js';
+/** One refusal representation; subclasses preserve the graph-port and record-loader boundaries. */
+export declare class EvidenceRefusal extends Error {
+    readonly code: GapCode;
+    constructor(code: GapCode, message: string);
+}
+export type RefuseEvidence = (code?: GapCode) => Error;
+interface DescriptorPolicy {
+    readonly translateTrapErrors: boolean;
+    readonly requireOwnValue: boolean;
+}
+/** Read data descriptors only; each boundary keeps its existing treatment of proxy traps. */
+export declare function ownData(value: unknown, key: string, refuse: RefuseEvidence, policy: DescriptorPolicy): unknown;
+/** Names share one grammar, with explicit limits and the record path separator exception. */
+export declare function boundedName(value: unknown, maximum: number, refuse: RefuseEvidence, path?: boolean): string;
+/** Bound iteration before reading entries, without invoking element accessors. */
+export declare function boundedList<T>(value: unknown, maximum: number, read: (item: unknown) => T, options: {
+    readonly refuse: RefuseEvidence;
+    readonly overflow: GapCode;
+    readonly freeze: boolean;
+    readonly descriptors: DescriptorPolicy;
+    /** Optional prior shape inspection must refer to the same admitted length. */
+    readonly expectedLength?: number;
+    /** New boundaries may normalize revoked-array errors without changing existing reader policy. */
+    readonly translateArrayErrors?: boolean;
+}): readonly T[];
+/** Charge retained fields against the same mutable allowance across admission helpers. */
+export declare function spendFields(budget: {
+    left: number;
+}, count: number, refuse: RefuseEvidence): void;
+export {};

package/dist/types/lib/evidence/codes.d.ts

@@ -0,0 +1,33 @@
+/** One vocabulary; true marks a domain evidence reason, false a trace/admission gap only. */
+export declare const GAP_CODES: Readonly<{
+    readonly 'not-collected': true;
+    readonly 'untracked-input': false;
+    readonly redacted: true;
+    readonly conservative: false;
+    readonly 'scope-boundary': false;
+    readonly 'invalid-data': true;
+    readonly unavailable: true;
+    readonly timeout: true;
+    readonly cancelled: false;
+    readonly cycle: false;
+    readonly 'node-limit': false;
+    readonly 'depth-limit': false;
+    readonly 'edge-limit': false;
+    readonly 'call-limit': false;
+    readonly truncated: false;
+    readonly 'strategy-failed': false;
+    readonly 'not-checked': true;
+    readonly 'no-match': true;
+    readonly ambiguous: true;
+    readonly stale: true;
+    readonly incompatible: true;
+    readonly unsupported: true;
+    readonly 'not-permitted': true;
+}>;
+export type GapCode = keyof typeof GAP_CODES;
+/** Producer-asserted evidence reasons, excluding traversal and admission bounds. */
+export type RequirementReason = {
+    [Code in GapCode]: (typeof GAP_CODES)[Code] extends true ? Code : never;
+}[GapCode];
+export declare const isGapCode: (value: unknown) => value is "not-collected" | "untracked-input" | "redacted" | "conservative" | "scope-boundary" | "invalid-data" | "unavailable" | "timeout" | "cancelled" | "cycle" | "node-limit" | "depth-limit" | "edge-limit" | "call-limit" | "truncated" | "strategy-failed" | "not-checked" | "no-match" | "ambiguous" | "stale" | "incompatible" | "unsupported" | "not-permitted";
+export declare const isRequirementReason: (value: unknown) => value is RequirementReason;

package/dist/types/lib/evidence/requirementTypes.d.ts

@@ -0,0 +1,46 @@
+import type { RequirementReason } from './codes.js';
+/**
+ * Existing check wire words; a disposition records a producer assertion, not authorization.
+ * `unreachable` means the check could not run; its reason identifies why.
+ */
+export type RequirementCheckDisposition = 'checked-pass' | 'checked-fail' | 'unreachable' | 'not-applicable';
+/** References to a real check and its retained evidence. No synthetic attempt is required or invented. */
+export interface RequirementCheck {
+    readonly checkRef: string;
+    readonly disposition: RequirementCheckDisposition;
+    readonly reason?: RequirementReason;
+    /** A namespaced adapter detail ID, never a message, subject or payload. */
+    readonly detail?: string;
+    readonly evidenceRefs: readonly string[];
+    readonly attemptRefs: readonly string[];
+}
+interface RequirementBinding {
+    /** This result's identity, not the enclosing artifact reference minted by storage. */
+    readonly id: string;
+    /** Reference to the requirement definition or policy. */
+    readonly requirementRef: string;
+    readonly findingRef: string;
+    readonly windowRef: string;
+    readonly affects: readonly string[];
+    readonly evidenceRefs: readonly string[];
+    readonly checks: readonly RequirementCheck[];
+    /** References into a host-owned closed action registry; never executable tool names or arguments. */
+    readonly actionRefs: readonly string[];
+    /** A namespaced adapter detail ID, never a message, subject or payload. */
+    readonly detail?: string;
+    /** Source validity and learned time are separate opaque references; no freshness inference is made. */
+    readonly validTimeRef?: string;
+    readonly learnedTimeRef?: string;
+}
+/**
+ * A producer assertion. Structural admission does not verify its source, scope, bindings, validity or truth.
+ * Hosts must verify those facts and must not let a satisfied record override an unresolved affected claim.
+ */
+export type RequirementResult = RequirementBinding & ({
+    readonly state: 'satisfied';
+    readonly reason?: never;
+} | {
+    readonly state: 'unresolved';
+    readonly reason: RequirementReason;
+});
+export {};

package/dist/types/lib/evidence/requirements.d.ts

@@ -0,0 +1,24 @@
+import { EvidenceRefusal } from './admission.js';
+import { type GapCode } from './codes.js';
+import type { RequirementResult } from './requirementTypes.js';
+/** Fixed per-call ceilings; characters are UTF-16 code units, not serialized transport bytes. */
+export declare const REQUIREMENT_RESULT_LIMITS: Readonly<{
+    results: 512;
+    checks: 16;
+    affects: 32;
+    refs: 16;
+    name: 512;
+    fields: 32768;
+    characters: 1048576;
+}>;
+/** No input, field value or originating exception is retained on a refusal. */
+export declare class RequirementValidationError extends EvidenceRefusal {
+    constructor(code?: GapCode);
+}
+/**
+ * Atomically project detached, frozen reference-only records. This is structural admission only.
+ * The host must authenticate producers, resolve authorized artifacts, verify current query/run/scope and
+ * domain validity, and enforce every unresolved affects reference before rendering any factual claim.
+ * Identifier grammar does not classify secrets; producers must supply non-secret identifiers only.
+ */
+export declare function readRequirementResults(value: unknown): readonly RequirementResult[];

package/dist/types/lib/memory/types.d.ts

@@ -2,10 +2,11 @@
  * types.ts — the record's types: a bundle, its rows, its patches, its encoding, and the
  * execution tree as the record's readers read it.
  *
- * Imports nothing. The standalone record names nothing outside itself: the engine's frame
+ * Imports only the record's leaf attention type. The record names nothing outside itself: the engine's frame
  * types — the stage snapshot, flow messages and retention dials — remain in FootPrint's
  * `frameTypes.ts`. The closed record graph is enforced by scripts/check-layering.mjs.
  */
+import type { Attention } from '../cause/types.js';
 /** A flat key-value bag representing a state patch (overwrite or merge). */
 export interface MemoryPatch {
     [key: string]: any;
@@ -194,6 +195,8 @@ export type CommitValuesMode = 'full' | 'delta';
  * ```
  */
 export interface ExecutionTree {
+    /** Optional recorded business attention; absence does not assert health. */
+    readonly attention?: readonly Attention[];
     /** The stage's id (prefixed inside a subflow). `commitStops` reads the root's to place a subflow's seed. */
     readonly id?: string;
     /** `[subflowPath/]stageId#executionIndex` — what a reader keys on. A node without one is not a stage. */

package/package.json

@@ -1,45 +1,99 @@
 {
   "name": "foottrace",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "type": "commonjs",
-  "description": "Execution records, replay, time travel and honest attribution — independent of the engine that produced them",
+  "description": "Execution records, replay, time travel and honest attribution \u2014 independent of the engine that produced them",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan <sanjay@footprintjs.dev>",
-  "repository": { "type": "git", "url": "git+https://github.com/footprintjs/foottrace.git" },
-  "bugs": { "url": "https://github.com/footprintjs/foottrace/issues" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/footprintjs/foottrace.git"
+  },
+  "bugs": {
+    "url": "https://github.com/footprintjs/foottrace/issues"
+  },
   "homepage": "https://github.com/footprintjs/foottrace#readme",
-  "engines": { "node": ">=22" },
+  "engines": {
+    "node": ">=22"
+  },
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
-  "files": ["dist/"],
+  "files": [
+    "dist/"
+  ],
   "exports": {
-    ".": { "import": { "types": "./dist/esm/index.d.ts", "default": "./dist/esm/index.js" }, "require": { "types": "./dist/types/index.d.ts", "default": "./dist/index.js" } },
-    "./write": { "import": { "types": "./dist/esm/write.d.ts", "default": "./dist/esm/write.js" }, "require": { "types": "./dist/types/write.d.ts", "default": "./dist/write.js" } },
-    "./paths": { "import": { "types": "./dist/esm/paths.d.ts", "default": "./dist/esm/paths.js" }, "require": { "types": "./dist/types/paths.d.ts", "default": "./dist/paths.js" } },
-    "./package.json": "./package.json"
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./write": {
+      "import": {
+        "types": "./dist/esm/write.d.ts",
+        "default": "./dist/esm/write.js"
+      },
+      "require": {
+        "types": "./dist/types/write.d.ts",
+        "default": "./dist/write.js"
+      }
+    },
+    "./paths": {
+      "import": {
+        "types": "./dist/esm/paths.d.ts",
+        "default": "./dist/esm/paths.js"
+      },
+      "require": {
+        "types": "./dist/types/paths.d.ts",
+        "default": "./dist/paths.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./cause": {
+      "import": {
+        "types": "./dist/esm/cause.d.ts",
+        "default": "./dist/esm/cause.js"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "write": [
+        "dist/types/write.d.ts"
+      ],
+      "paths": [
+        "dist/types/paths.d.ts"
+      ],
+      "cause": [
+        "dist/esm/cause.d.ts"
+      ]
+    }
   },
-  "typesVersions": { "*": { "write": ["dist/types/write.d.ts"], "paths": ["dist/types/paths.d.ts"] } },
   "scripts": {
     "build": "tsc -p tsconfig.json && tsc -p tsconfig.esm.json && node scripts/postbuild-esm.mjs",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc -p tsconfig.test.json",
     "check:layering": "node scripts/check-layering.mjs",
-    "check:package": "publint && attw --pack",
+    "check:package": "publint && attw --pack --exclude-entrypoints cause --profile strict && attw --pack --entrypoints cause --profile esm-only",
     "lint": "eslint 'src/**/*.ts'",
     "format": "prettier --check 'src/**/*.ts' 'test/**/*.ts'",
     "test:examples": "tsc -p examples/tsconfig.json",
     "check": "npm run build && npm run typecheck && npm test && npm run check:layering && npm run lint && npm run format && npm run check:package && npm run test:examples"
   },
-  "dependencies": {},
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.1",
     "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^8.71.1",
     "@typescript-eslint/parser": "^8.71.1",
     "@vitest/coverage-v8": "4.1.11",
+    "esbuild": "0.28.2",
     "eslint": "^8.57.1",
     "fast-check": "^4.4.0",
     "prettier": "^2.8.1",