@weiliang0121/capix-records 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # @weiliang0121/capix-records
 
-Optional recording entities and resource contracts for CAPiX.
+Optional recording entities and resource packages/contracts for CAPiX.
 
 ES modules and TypeScript declarations. Requires Node.js 22.23.2 or newer.
 
@@ -12,9 +12,18 @@ npm install @weiliang0121/capix-records
 
 - `@weiliang0121/capix-records`
 - `@weiliang0121/capix-records/construction`
+- `@weiliang0121/capix-records/data`
+
+The root entry exports live record entities and recording helpers. The `data` entry owns their plain record shapes, archive identities, change records, output resolution, and full subtree/body validation. It has no Node.js or live-entity imports and is suitable for browser and wire consumers. Identically named data interfaces and entity classes are deliberately separated by these entries.
+
+`CallableRecordHelper.snapshot` reads the caller-selected invocation subtree and its actual ancestor path; selecting a business task, Observer overview, and environment aggregation remain application responsibilities. `ExecutionRecordHelper.snapshot` and the corresponding legacy-named validators retain their existing record representation and validation; these APIs do not upgrade old data or resume execution. Memory recording and `observeMemory` expose only `MemoryRecordContent` (`content`) and available records, not arbitrary metadata or recovery material.
+
+This ownership change removes the dependency on `capix-protocol`. Consumers of the former protocol recording/archive exports must import `capix-records/data`; shared invocation vocabulary belongs to `capix-contracts`.
+
+`ResourceRecord.sequence` retains the owning call's shared resource order, which also numbers forwarded domain facts. Because those facts are projected separately or intentionally left uninterpreted, resource record numbers may have gaps. Subtree validation and record-book restoration require positive safe integers in strictly increasing order per owner; identity, binding phases, and started/returned/threw pairing remain checked. Missing numbers do not establish missing effects or authorize replay.
 
 This package is part of CAPiX. The npm distribution contains compiled JavaScript, type declarations, and this package's MIT license. Reference services and client applications are not included in this package or the initial npm release.
 
 ## License
 
-MIT. Copyright (c) 2026 wei.liang. See [LICENSE](./LICENSE).
+MIT. Copyright (c) 2026 wei.liang. See [LICENSE](LICENSE).

package/dist/attempt/record.d.ts

@@ -1,4 +1,4 @@
-import type { AttemptRecord as AttemptData, AttemptValue } from '@weiliang0121/capix-protocol';
+import type { AttemptRecord as AttemptData, AttemptValue } from '../data/index.js';
 import { InvocationRecord } from '../invocation/record.js';
 export type AttemptRecordOptions = Omit<AttemptData, 'id' | 'value' | 'status' | 'parentId' | 'childIds'>;
 export declare class AttemptRecord extends InvocationRecord<AttemptValue> implements AttemptData {

package/dist/book.d.ts

@@ -1,6 +1,6 @@
 import type { BaseRecord } from './record.js';
 import { removeRegistration } from './tree/access.js';
-import type { RecordEntry } from '@weiliang0121/capix-protocol';
+import type { RecordEntry } from './data/index.js';
 export interface RecordBookState {
     readonly entries: readonly RecordEntry[];
 }

package/dist/callable/helper.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionRecordSnapshot } from '@weiliang0121/capix-protocol';
+import type { ExecutionRecordSnapshot } from '../data/index.js';
 import type { Recorder } from '../recorder.js';
 export declare class CallableRecordHelper {
     static snapshot(recorder: Recorder, id: string): ExecutionRecordSnapshot;

package/dist/callable/record.d.ts

@@ -1,4 +1,4 @@
-import type { CallableRecord as CallableRecordData, CallableValue } from '@weiliang0121/capix-protocol';
+import type { CallableRecord as CallableRecordData, CallableValue } from '../data/index.js';
 import { InvocationRecord } from '../invocation/record.js';
 export type CallableRecordOptions = Omit<CallableRecordData, 'id' | 'value' | 'status' | 'childIds'>;
 export declare class CallableRecord extends InvocationRecord<CallableValue> implements CallableRecordData {

package/dist/construction.d.ts

@@ -1,5 +1,5 @@
 import { ResourceOffer } from '@weiliang0121/capix-resources';
-import type { InvocationBoundaryValue, RecordMutation } from '@weiliang0121/capix-protocol';
+import type { InvocationBoundaryValue, RecordMutation } from './data/index.js';
 import type { BaseRecord } from './record.js';
 import type { Recorder } from './recorder.js';
 import { InvocationBoundaryRecordHelper } from './invocation/boundary/helper.js';

package/dist/content.d.ts

@@ -0,0 +1,10 @@
+import { type TranscriptEvent } from '@weiliang0121/capix-transcript';
+import { type MemoryEvent } from '@weiliang0121/capix-memory';
+import type { ResourceFact } from '@weiliang0121/capix-resources';
+import type { RecordWriter } from './construction.js';
+import type { RecordChangeSource } from './source.js';
+import { TranscriptRecord } from './transcript/record.js';
+import { MemoryRecord } from './memory/record.js';
+export declare function transcriptRecord(event: TranscriptEvent, source?: RecordChangeSource): TranscriptRecord;
+export declare function memoryRecord(event: MemoryEvent<unknown>, source?: RecordChangeSource): MemoryRecord;
+export declare function recordContentFact(fact: ResourceFact, source: RecordChangeSource, writer: RecordWriter): void;

package/dist/content.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{TranscriptFacts}from"@weiliang0121/capix-transcript";import{MemoryFacts}from"@weiliang0121/capix-memory";import{TranscriptRecord}from"./transcript/record.js";import{MemoryRecord}from"./memory/record.js";function transcriptRecord(event,source){const change=event.change;return new TranscriptRecord({transcriptId:event.transcriptId,revision:event.revision,occurredAt:event.occurredAt,...source?{source}:{}},change.kind==="messages-appended"?{action:"append",start:change.start,end:change.start+change.messages.length}:{action:"segment",previousStart:change.previousStart,start:change.start,end:change.end})}__name(transcriptRecord,"transcriptRecord");function memoryRecord(event,source){return new MemoryRecord({memoriesId:event.memoriesId,memoryId:event.change.memoryId,sequence:event.sequence,...source?{source}:{}},{action:event.change.action,...event.change.reason!==void 0?{reason:event.change.reason}:{},result:{content:event.change.value.content}})}__name(memoryRecord,"memoryRecord");function recordContentFact(fact,source,writer){if(fact.contextId!==source.contextId)throw new Error("Content fact forwarding context does not match record source");TranscriptFacts.match(fact.fact,event=>{if(event.origin?.contextId!==source.contextId)throw new Error("Transcript fact origin does not match record source");writer.add(transcriptRecord(event,source))})||MemoryFacts.match(fact.fact,event=>{if(event.origin?.contextId!==source.contextId)throw new Error("Memory fact origin does not match record source");writer.add(memoryRecord(event,source))})}__name(recordContentFact,"recordContentFact");export{memoryRecord,recordContentFact,transcriptRecord};

package/dist/data/archive.d.ts

@@ -0,0 +1,9 @@
+export interface RecordingArchive {
+    readonly sourceId: string;
+    readonly rootIds: readonly string[];
+    readonly revision: number;
+    readonly state: 'open' | 'sealed' | 'incomplete';
+}
+export type RecordingArchiveOrigin = Omit<RecordingArchive, 'rootIds'>;
+export declare function validateRecordingArchiveOrigin(value: unknown): asserts value is RecordingArchiveOrigin;
+export declare function validateRecordingArchives(value: unknown): asserts value is readonly RecordingArchive[];

package/dist/data/archive.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});function validateRecordingArchiveOrigin(value){if(!value||typeof value!="object")throw new Error("\u5386\u53F2\u8BB0\u5F55\u6765\u6E90\u683C\u5F0F\u65E0\u6548\u3002");const source=value;if(typeof source.sourceId!="string"||!source.sourceId||!Number.isSafeInteger(source.revision)||source.revision<0||!["open","sealed","incomplete"].includes(source.state))throw new Error("\u5386\u53F2\u8BB0\u5F55\u6765\u6E90\u683C\u5F0F\u65E0\u6548\u3002")}__name(validateRecordingArchiveOrigin,"validateRecordingArchiveOrigin");function validateRecordingArchives(value){if(!Array.isArray(value))throw new Error("\u5386\u53F2\u8BB0\u5F55\u6765\u6E90\u683C\u5F0F\u65E0\u6548\u3002");const sources=new Set,roots=new Set;for(const archive of value){validateRecordingArchiveOrigin(archive);const source=archive;if(sources.has(source.sourceId)||!Array.isArray(source.rootIds)||source.rootIds.some(id=>typeof id!="string"||!id||roots.has(id)))throw new Error("\u5386\u53F2\u8BB0\u5F55\u6765\u6E90\u5F52\u5C5E\u65E0\u6548\u3002");sources.add(source.sourceId);for(const id of source.rootIds){if(roots.has(id))throw new Error("\u5386\u53F2\u8BB0\u5F55\u6765\u6E90\u5F52\u5C5E\u65E0\u6548\u3002");roots.add(id)}}}__name(validateRecordingArchives,"validateRecordingArchives");export{validateRecordingArchiveOrigin,validateRecordingArchives};

package/dist/data/changes.d.ts

@@ -0,0 +1,43 @@
+import type { BaseRecord, ProcessRecord, RelationChangeRecord } from './types.js';
+import type { RuntimeErrorValue, InvocationFailureFact } from '@weiliang0121/capix-contracts';
+export type RecordKind = 'invocation' | 'runtime' | 'runtime-call' | 'execution' | 'operation' | 'attempt' | 'invocation-boundary' | 'transcript' | 'memory' | 'resource' | 'custom';
+export interface RecordEntry {
+    readonly kind: RecordKind;
+    readonly data: BaseRecord;
+}
+export type RecordMutation = Readonly<{
+    kind: 'added';
+    entry: RecordEntry;
+    parent?: Readonly<{
+        id: string;
+        childId: string;
+    }>;
+}> | Readonly<{
+    kind: 'process-appended';
+    id: string;
+    process: ProcessRecord;
+}> | Readonly<{
+    kind: 'relation-appended';
+    id: string;
+    relation: RelationChangeRecord;
+}> | Readonly<{
+    kind: 'finished';
+    id: string;
+    status: 'succeeded' | 'failed';
+    result: Readonly<{
+        output?: unknown;
+        resultOf?: number;
+        error?: RuntimeErrorValue;
+        failure?: InvocationFailureFact;
+    }>;
+}> | Readonly<{
+    kind: 'replaced';
+    entry: RecordEntry;
+}>;
+export type RecordChangeEvent = Readonly<{
+    type: 'record';
+    recorderId: string;
+    revision: number;
+    occurredAt: string;
+    change: RecordMutation;
+}>;

package/dist/data/changes.js

@@ -0,0 +1 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */

package/dist/data/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types.js';
+export * from './invocation.js';
+export * from './memory.js';
+export * from './transcript.js';
+export * from './resource.js';
+export * from './changes.js';
+export * from './archive.js';
+export * from './validate.js';

package/dist/data/index.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+export*from"./types.js";export*from"./invocation.js";export*from"./memory.js";export*from"./transcript.js";export*from"./resource.js";export*from"./changes.js";export*from"./archive.js";export*from"./validate.js";

package/dist/data/invocation.d.ts

@@ -0,0 +1,10 @@
+import type { InvocationValue, ProcessRecord } from './types.js';
+type OutputProcess = Extract<ProcessRecord, {
+    type: 'return';
+    output: unknown;
+}>;
+export declare function outputProcess(value: Pick<InvocationValue, 'processes'>, sequence: number, before?: number): OutputProcess;
+export declare function hasOutput(value: InvocationValue): boolean;
+export declare function finalOutputProcess(value: Pick<InvocationValue, 'processes'>, sequence: number): OutputProcess;
+export declare function readOutput<Input, Output>(value: InvocationValue<Input, Output>): Output | undefined;
+export {};

package/dist/data/invocation.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});function outputProcess(value,sequence,before=value.processes.length+1){const process=value.processes[sequence-1];if(!Number.isSafeInteger(sequence)||sequence<1||sequence>=before||!process||process.sequence!==sequence||process.type!=="return"||!Object.hasOwn(process,"output")||Object.hasOwn(process,"resultOf"))throw new Error("Invalid local result reference");return process}__name(outputProcess,"outputProcess");function hasOutput(value){return Object.hasOwn(value,"output")||Object.hasOwn(value,"resultOf")}__name(hasOutput,"hasOutput");function finalOutputProcess(value,sequence){const last=value.processes.at(-1);if(!last||last.type!=="return"||sequence!==("resultOf"in last?last.resultOf:last.sequence))throw new Error("Final result must reference the last returned output");return outputProcess(value,sequence)}__name(finalOutputProcess,"finalOutputProcess");function readOutput(value){if(Object.hasOwn(value,"resultOf")){if(Object.hasOwn(value,"output"))throw new Error("Output and local result reference are mutually exclusive");return finalOutputProcess(value,value.resultOf).output}return value.output}__name(readOutput,"readOutput");export{finalOutputProcess,hasOutput,outputProcess,readOutput};

package/dist/data/memory.d.ts

@@ -0,0 +1,26 @@
+import type { BaseRecord } from './types.js';
+export interface MemoryRecordContent {
+    readonly content: string;
+}
+export interface MemoryRecordObservation {
+    readonly items: readonly {
+        readonly id: string;
+        readonly value: MemoryRecordContent;
+        readonly records: readonly MemoryRecord[];
+    }[];
+}
+export interface MemoryRecordValue {
+    readonly action: 'create' | 'update';
+    readonly reason?: string;
+    readonly result: MemoryRecordContent;
+}
+export interface MemoryRecord extends BaseRecord<MemoryRecordValue> {
+    readonly memoryId: string;
+    readonly memoriesId: string;
+    readonly sequence: number;
+    readonly contextId?: string;
+    readonly callId?: string;
+    readonly executionId?: string;
+    readonly operationId?: string;
+}
+export declare function validateMemoryRecordValue(value: unknown): asserts value is MemoryRecordValue;

package/dist/data/memory.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});function validateMemoryRecordValue(value){if(!value||typeof value!="object"||Array.isArray(value))throw new Error("Invalid memory record value");const record=value;if(!Object.hasOwn(record,"action")||!Object.hasOwn(record,"result")||record.action!=="create"&&record.action!=="update"||Object.keys(record).some(key=>!["action","reason","result"].includes(key))||Object.hasOwn(record,"reason")&&typeof record.reason!="string")throw new Error("Invalid memory record value");const result=record.result;if(!result||typeof result!="object"||Array.isArray(result)||Object.keys(result).length!==1||!Object.hasOwn(result,"content")||typeof result.content!="string")throw new Error("Invalid memory display value")}__name(validateMemoryRecordValue,"validateMemoryRecordValue");export{validateMemoryRecordValue};

package/dist/data/resource.d.ts

@@ -0,0 +1,10 @@
+import type { BaseRecord } from './types.js';
+export interface ResourceRecord<Detail = unknown> extends BaseRecord<Detail> {
+    readonly parentId: string;
+    readonly access: string;
+    readonly supplyId: string;
+    readonly sequence: number;
+    readonly occurredAt: string;
+    readonly phase: 'bound' | 'available' | 'unavailable' | 'started' | 'returned' | 'threw';
+    readonly interactionId?: string;
+}

package/dist/data/resource.js

@@ -0,0 +1 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */

package/dist/data/transcript.d.ts

@@ -0,0 +1,19 @@
+import type { BaseRecord } from './types.js';
+export type TranscriptChange = {
+    readonly action: 'append';
+    readonly start: number;
+    readonly end: number;
+} | {
+    readonly action: 'segment';
+    readonly previousStart: number;
+    readonly start: number;
+    readonly end: number;
+};
+export interface TranscriptRecord extends BaseRecord<TranscriptChange> {
+    readonly transcriptId: string;
+    readonly revision: number;
+    readonly occurredAt: string;
+    readonly contextId?: string;
+    readonly callId?: string;
+    readonly executionId?: string;
+}

package/dist/data/transcript.js

@@ -0,0 +1 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */

package/dist/data/types.d.ts

@@ -0,0 +1,189 @@
+import type { RecordingArchiveOrigin } from './archive.js';
+import type { InvocationFailureFact, RuntimeErrorValue } from '@weiliang0121/capix-contracts';
+import type { CallableKind } from '@weiliang0121/capix-contracts';
+import type { TranscriptRecord } from './transcript.js';
+import type { MemoryRecord } from './memory.js';
+import type { ResourceRecord } from './resource.js';
+import type { InvocationRelationIdentity } from '@weiliang0121/capix-contracts';
+export interface BaseRecord<Value = unknown> {
+    readonly id: string;
+    readonly parentId?: string;
+    readonly value: Value;
+}
+export interface CompositeRecord<Value = unknown> extends BaseRecord<Value> {
+    readonly childIds: readonly string[];
+}
+export interface RecordingRootValue {
+    readonly createdAt: string;
+}
+export interface RecordingRootRecord extends CompositeRecord<RecordingRootValue> {
+}
+export type ProcessRecord = Readonly<{
+    sequence: number;
+    eventSequence: number;
+    round: number;
+    occurredAt: string;
+    offsetMs: number;
+} & ({
+    stage: 'execute';
+    type: 'start';
+    input: unknown;
+} | {
+    stage: 'execute' | 'receive' | 'handling';
+    type: 'return';
+    output: unknown;
+} | {
+    stage: 'receive';
+    type: 'return';
+    resultOf: number;
+} | {
+    stage: 'execute' | 'receive' | 'handling';
+    type: 'throw';
+    error: RuntimeErrorValue;
+    failure?: InvocationFailureFact;
+} | {
+    stage: 'receive' | 'handling';
+    type: 'continue';
+    input: unknown;
+    reason: string;
+} | {
+    stage: 'handling';
+    type: 'start' | 'unhandled';
+    error: RuntimeErrorValue;
+    failure?: InvocationFailureFact;
+} | {
+    stage: 'control';
+    type: 'stop';
+    error: RuntimeErrorValue;
+    failure?: InvocationFailureFact;
+})>;
+export type RecordedInvocationResult = Readonly<{
+    status: 'succeeded';
+    output: unknown;
+} | {
+    status: 'failed';
+    error: RuntimeErrorValue;
+    failure?: InvocationFailureFact;
+}>;
+export type RecordedRelationChange = Readonly<{
+    kind: 'attached';
+} | {
+    kind: 'returned';
+    result: RecordedInvocationResult;
+} | {
+    kind: 'receiving';
+} | {
+    kind: 'accepted';
+    output: unknown;
+} | {
+    kind: 'handled';
+    output: unknown;
+} | {
+    kind: 'failed';
+    source: 'work' | 'observation';
+    error: RuntimeErrorValue;
+    failure?: InvocationFailureFact;
+}>;
+export interface RelationChangeRecord {
+    readonly identity: InvocationRelationIdentity;
+    readonly eventSequence: number;
+    readonly occurredAt: string;
+    readonly offsetMs: number;
+    readonly childId?: string;
+    readonly change: RecordedRelationChange;
+}
+export interface InvocationValue<Input = unknown, Output = unknown> {
+    readonly processes: readonly ProcessRecord[];
+    readonly relationChanges: readonly RelationChangeRecord[];
+    input: Input;
+    output?: Output;
+    resultOf?: number;
+    error?: RuntimeErrorValue;
+    failure?: InvocationFailureFact;
+}
+export interface RuntimeCallValue<Input = unknown, Output = unknown> extends InvocationValue<Input, Output> {
+    readonly startedAt: string;
+}
+export interface RuntimeCallRecord<Input = unknown, Output = unknown> extends CompositeRecord<RuntimeCallValue<Input, Output>> {
+    readonly contextId: string;
+    readonly runtimeInstanceId: string;
+    readonly status: 'running' | 'succeeded' | 'failed';
+}
+export interface ExecutionValue<Input = unknown, Output = unknown> extends InvocationValue<Input, Output> {
+    startedAt: string;
+}
+export interface ExecutionRecord<Input = unknown, Output = unknown> extends CompositeRecord<ExecutionValue<Input, Output>> {
+    readonly contextId: string;
+    readonly status: 'running' | 'succeeded' | 'failed';
+}
+export interface OperationRecord<Input = unknown, Output = unknown> extends CompositeRecord<InvocationValue<Input, Output>> {
+    readonly contextId: string;
+    readonly status: 'running' | 'succeeded' | 'failed';
+    readonly executionId: string;
+    readonly operationInstanceId: string;
+    readonly parentOperationId?: string;
+    readonly operation: string;
+    readonly label: string;
+    readonly source: string;
+    readonly caller: string;
+    readonly callee: string;
+}
+export interface AttemptValue<Input = unknown, Output = unknown> extends InvocationValue<Input, Output> {
+}
+export interface AttemptRecord<Input = unknown, Output = unknown> extends CompositeRecord<AttemptValue<Input, Output>> {
+    readonly contextId: string;
+    readonly status: 'running' | 'succeeded' | 'failed';
+    readonly operationId: string;
+    readonly name: string;
+    readonly label: string;
+    readonly source: string;
+    readonly caller: string;
+    readonly callee: string;
+}
+export interface InvocationBoundaryValue {
+    readonly type: 'call' | 'return' | 'throw';
+    readonly scope: 'work';
+}
+export interface InvocationBoundaryRecord extends BaseRecord<InvocationBoundaryValue> {
+    readonly scopeId: string;
+    readonly executionId?: string;
+    readonly callId: string;
+    readonly sequence: number;
+    readonly occurredAt: string;
+    readonly offsetMs: number;
+}
+export interface LegacyExecutionRecordSnapshot {
+    readonly archive?: RecordingArchiveOrigin;
+    runtimeCall: RuntimeCallRecord;
+    runtimeEvents: InvocationBoundaryRecord[];
+    execution: ExecutionRecord;
+    operations: OperationRecord[];
+    attempts: AttemptRecord[];
+    events: InvocationBoundaryRecord[];
+    resources: ResourceRecord[];
+}
+export interface CallableValue<Input = unknown, Output = unknown> extends InvocationValue<Input, Output> {
+    readonly startedAt?: string;
+}
+export interface CallableRecord<Input = unknown, Output = unknown> extends CompositeRecord<CallableValue<Input, Output>> {
+    readonly contextId: string;
+    readonly structureKind: CallableKind;
+    readonly structureId?: string;
+    readonly name?: string;
+    readonly label?: string;
+    readonly source?: string;
+    readonly callee?: string;
+    readonly role?: string;
+    readonly status: 'running' | 'succeeded' | 'failed';
+}
+export interface ExecutionRecordSnapshot {
+    readonly archive?: RecordingArchiveOrigin;
+    readonly execution: CallableRecord;
+    readonly calls: readonly CallableRecord[];
+    readonly rootCall?: CallableRecord;
+    readonly ancestors?: readonly CallableRecord[];
+    readonly boundaries: readonly InvocationBoundaryRecord[];
+    readonly transcripts: readonly TranscriptRecord[];
+    readonly memories: readonly MemoryRecord[];
+    readonly resources: readonly ResourceRecord[];
+}

package/dist/data/types.js

@@ -0,0 +1 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */

package/dist/data/validate.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionRecordSnapshot, LegacyExecutionRecordSnapshot, InvocationValue } from './types.js';
+export declare function validateExecutionRecordSnapshot(value: unknown): asserts value is ExecutionRecordSnapshot;
+export declare function validateLegacyExecutionRecordSnapshot(value: unknown): asserts value is LegacyExecutionRecordSnapshot;
+export declare function validateInvocationRecordValue(value: unknown, ownerContextId: string): asserts value is InvocationValue;

package/dist/data/validate.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{validateMemoryRecordValue}from"./memory.js";import{validateRecordingArchiveOrigin}from"./archive.js";import{hasOutput,outputProcess,readOutput}from"./invocation.js";function validateExecutionRecordSnapshot(value){function fail(){throw new Error("\u8C03\u7528\u8BB0\u5F55\u683C\u5F0F\u65E0\u6548\u6216\u5173\u8054\u7F3A\u5931\u3002")}__name(fail,"fail"),(!value||typeof value!="object")&&fail();const snapshot=value;snapshot.archive!==void 0&&validateRecordingArchiveOrigin(snapshot.archive),(!snapshot.execution||!Array.isArray(snapshot.calls)||!Array.isArray(snapshot.boundaries)||!Array.isArray(snapshot.resources)||!Array.isArray(snapshot.transcripts)||!Array.isArray(snapshot.memories))&&fail();const records=new Map,contexts=new Set,accept=__name(record=>{(!record||typeof record.id!="string"||!record.id||typeof record.contextId!="string"||!record.contextId||record.contextId===record.id||records.has(record.id)||contexts.has(record.id)||records.has(record.contextId)||contexts.has(record.contextId)||!["scene","group","node"].includes(record.structureKind)||!Array.isArray(record.childIds)||new Set(record.childIds).size!==record.childIds.length||record.childIds.some(id=>typeof id!="string"||!id)||!record.value)&&fail(),(record.value.startedAt===void 0?!snapshot.archive:typeof record.value.startedAt!="string"||!Number.isFinite(Date.parse(record.value.startedAt)))&&fail();for(const key of["structureId","name","label","callee","role"])record[key]!==void 0&&(typeof record[key]!="string"||!record[key].trim())&&fail();record.source!==void 0&&typeof record.source!="string"&&fail(),record.parentId!==void 0&&(typeof record.parentId!="string"||!record.parentId)&&fail(),validateInvocationRecordValue(record.value,record.contextId),validRecordedStatus(record.status,record.value)||fail(),records.set(record.id,record),contexts.add(record.contextId)},"accept");for(const record of snapshot.calls)accept(record);const selected=records.get(snapshot.execution.id);(!selected||JSON.stringify(selected)!==JSON.stringify(snapshot.execution))&&fail(),snapshot.rootCall&&snapshot.rootCall.id!==selected.id?accept(snapshot.rootCall):snapshot.rootCall&&JSON.stringify(snapshot.rootCall)!==JSON.stringify(selected)&&fail(),snapshot.ancestors!==void 0&&!Array.isArray(snapshot.ancestors)&&fail();const ancestors=snapshot.ancestors??[];ancestors.length&&(!snapshot.rootCall||snapshot.rootCall.id===selected.id)&&fail();for(const ancestor of ancestors)accept(ancestor);const path=snapshot.rootCall&&snapshot.rootCall.id!==selected.id?[snapshot.rootCall,...ancestors,selected]:[selected];for(let index=1;index<path.length;index++){const parent=path[index-1],child=path[index];(parent.structureKind==="node"||child.parentId!==parent.id||!parent.childIds.includes(child.id))&&fail()}const root=path[0];root.parentId&&records.has(root.parentId)&&fail();for(const record of snapshot.calls){if(contexts.has(record.id)&&fail(),record.id===selected.id)continue;const visited=new Set([record.id]);let current=record;for(;current.id!==selected.id;){const parent=current.parentId?records.get(current.parentId):void 0;(!parent||visited.has(parent.id)||parent.structureKind==="node"||!parent.childIds.includes(current.id))&&fail(),visited.add(parent.id),current=parent}}for(const record of records.values()){record.structureKind==="scene"&&record.parentId&&records.has(record.parentId)&&fail();for(const relation of record.value.relationChanges){const child=relation.childId?records.get(relation.childId):void 0;child&&(child.parentId!==record.id||child.contextId!==relation.identity.childContextId)&&fail()}}const seen=new Set([...records.keys(),...contexts]),timing=new Map,scopes=new Map;for(const boundary of snapshot.boundaries){const call=records.get(boundary?.callId),prior=scopes.get(boundary?.scopeId);(!boundary||typeof boundary.id!="string"||!boundary.id||seen.has(boundary.id)||!call||boundary.parentId!==call.id||typeof boundary.scopeId!="string"||!boundary.scopeId||!Number.isSafeInteger(boundary.sequence)||boundary.sequence<1||prior&&boundary.sequence<=prior.sequence||!Number.isFinite(boundary.offsetMs)||boundary.offsetMs<(prior?.offsetMs??0)||typeof boundary.occurredAt!="string"||!Number.isFinite(Date.parse(boundary.occurredAt))||boundary.value?.scope!=="work")&&fail(),!snapshot.archive&&(boundary.scopeId!==(snapshot.rootCall??selected).id||boundary.executionId!==void 0)&&fail(),seen.add(boundary.id),scopes.set(boundary.scopeId,{sequence:boundary.sequence,offsetMs:boundary.offsetMs});const state=timing.get(call.id)??{scopeId:boundary.scopeId};state.scopeId!==boundary.scopeId&&fail();const time=boundary.offsetMs;boundary.value.type==="call"?((state.started!==void 0||state.ended!==void 0)&&fail(),state.started=time):boundary.value.type==="return"||boundary.value.type==="throw"?((state.started===void 0||state.ended!==void 0||time<state.started||call.status!==(boundary.value.type==="return"?"succeeded":"failed"))&&fail(),state.ended=time):fail(),timing.set(call.id,state)}for(const record of records.values()){const time=timing.get(record.id);!snapshot.archive&&(!time||time.started===void 0||record.status!=="running"&&time.ended===void 0)&&fail();const parentTime=record.parentId?timing.get(record.parentId):void 0;time?.scopeId===parentTime?.scopeId&&(time?.started!==void 0&&parentTime?.started!==void 0&&time.started<parentTime.started&&fail(),time?.ended!==void 0&&parentTime?.ended!==void 0&&time.ended>parentTime.ended&&fail(),time?.started!==void 0&&parentTime?.ended!==void 0&&time.ended===void 0&&fail())}const resourceSequences=new Map,accesses=new Map,interactions=new Map;for(const resource of snapshot.resources){(!resource||typeof resource.id!="string"||!resource.id||seen.has(resource.id)||!records.has(resource.parentId)||typeof resource.access!="string"||!resource.access||typeof resource.supplyId!="string"||!resource.supplyId||typeof resource.occurredAt!="string"||!Number.isFinite(Date.parse(resource.occurredAt))||!Object.hasOwn(resource,"value")||!Number.isSafeInteger(resource.sequence)||resource.sequence<=(resourceSequences.get(resource.parentId)??0))&&fail(),resourceSequences.set(resource.parentId,resource.sequence),seen.add(resource.id);const key=JSON.stringify([resource.parentId,resource.supplyId,resource.access]);resource.phase==="bound"?((accesses.has(key)||resource.interactionId!==void 0)&&fail(),accesses.set(key,"bound")):resource.phase==="available"||resource.phase==="unavailable"?((accesses.get(key)!=="bound"||resource.interactionId!==void 0)&&fail(),accesses.set(key,resource.phase)):resource.phase==="started"?((accesses.get(key)!=="available"||typeof resource.interactionId!="string"||!resource.interactionId||interactions.has(resource.interactionId))&&fail(),interactions.set(resource.interactionId,key)):resource.phase==="returned"||resource.phase==="threw"?((typeof resource.interactionId!="string"||interactions.get(resource.interactionId)!==key)&&fail(),interactions.delete(resource.interactionId)):fail()}for(const memory of snapshot.memories)validateMemoryRecordValue(memory?.value);for(const content of[...snapshot.transcripts,...snapshot.memories]){const call=content.callId?records.get(content.callId):void 0;(!content||typeof content.id!="string"||!content.id||seen.has(content.id)||!call||content.parentId!==call.id||content.contextId!==call.contextId||!Object.hasOwn(content,"value"))&&fail(),seen.add(content.id)}}__name(validateExecutionRecordSnapshot,"validateExecutionRecordSnapshot");function validateLegacyExecutionRecordSnapshot(value){const fail=__name(()=>{throw new Error("\u8FD0\u884C\u8BB0\u5F55\u683C\u5F0F\u65E0\u6548\u6216\u5173\u8054\u7F3A\u5931\u3002")},"fail");if(!value||typeof value!="object")return fail();const snapshot=value;snapshot.archive!==void 0&&validateRecordingArchiveOrigin(snapshot.archive);const historical=snapshot.archive!==void 0;if(!snapshot.execution||typeof snapshot.execution.id!="string"||!snapshot.execution.id||!snapshot.execution.value||typeof snapshot.execution.value.startedAt!="string"||!Array.isArray(snapshot.operations)||!Array.isArray(snapshot.attempts)||!Array.isArray(snapshot.events)||!Array.isArray(snapshot.resources))return fail();const executionId=snapshot.execution.id,operations=new Map,parents=new Map,statuses=new Map([[executionId,snapshot.execution.status]]),bodies=new Map([[executionId,snapshot.execution.value]]),contextsByRecord=new Map,contextIds=new Set,acceptContextIdentity=__name(record=>{if(typeof record.contextId!="string"||!record.contextId||record.contextId===record.id||contextIds.has(record.contextId))return fail();contextIds.add(record.contextId),contextsByRecord.set(record.id,record.contextId)},"acceptContextIdentity");acceptContextIdentity(snapshot.execution);const runtimeCall=snapshot.runtimeCall;if(!runtimeCall||typeof runtimeCall.id!="string"||!runtimeCall.id||runtimeCall.id===executionId||typeof runtimeCall.runtimeInstanceId!="string"||!runtimeCall.runtimeInstanceId||!runtimeCall.value||typeof runtimeCall.value.startedAt!="string"||snapshot.execution.parentId!==runtimeCall.id||!["running","succeeded","failed"].includes(runtimeCall.status))return fail();acceptContextIdentity(runtimeCall);const validParticipant=__name(value2=>typeof value2=="string"&&value2.trim().length>0,"validParticipant");for(const operationRecord of snapshot.operations){if(!operationRecord||typeof operationRecord.id!="string"||!operationRecord.id||bodies.has(operationRecord.id)||operationRecord.executionId!==executionId||typeof operationRecord.operationInstanceId!="string"||!operationRecord.operationInstanceId||typeof operationRecord.operation!="string"||typeof operationRecord.label!="string"||typeof operationRecord.source!="string"||!validParticipant(operationRecord.caller)||!validParticipant(operationRecord.callee)||operationRecord.parentOperationId!==void 0&&typeof operationRecord.parentOperationId!="string")return fail();acceptContextIdentity(operationRecord),operations.set(operationRecord.id,operationRecord),parents.set(operationRecord.id,operationRecord.parentOperationId??executionId),statuses.set(operationRecord.id,operationRecord.status),bodies.set(operationRecord.id,operationRecord.value)}for(const attemptRecord of snapshot.attempts){if(!attemptRecord||typeof attemptRecord.id!="string"||!attemptRecord.id||bodies.has(attemptRecord.id)||typeof attemptRecord.operationId!="string"||!operations.has(attemptRecord.operationId)||typeof attemptRecord.name!="string"||!attemptRecord.name.trim()||typeof attemptRecord.label!="string"||!attemptRecord.label.trim()||typeof attemptRecord.source!="string"||!validParticipant(attemptRecord.caller)||!validParticipant(attemptRecord.callee))return fail();acceptContextIdentity(attemptRecord),parents.set(attemptRecord.id,attemptRecord.operationId),statuses.set(attemptRecord.id,attemptRecord.status),bodies.set(attemptRecord.id,attemptRecord.value)}if(bodies.has(runtimeCall.id))return fail();const observedBodies=new Map(bodies);observedBodies.set(runtimeCall.id,runtimeCall.value);for(const id of contextIds)if(observedBodies.has(id))return fail();for(const status of statuses.values())if(!["running","succeeded","failed"].includes(status))return fail();for(const[owner,body]of observedBodies)validateInvocationRecordValue(body,contextsByRecord.get(owner));for(const operationRecord of operations.values())if(operationRecord.parentOperationId!==void 0&&!operations.has(operationRecord.parentOperationId))return fail();for(const id of parents.keys()){const visited=new Set([id]);let ancestor=parents.get(id);for(;ancestor&&ancestor!==executionId;){if(visited.has(ancestor))return fail();visited.add(ancestor),ancestor=parents.get(ancestor)}}const active=new Set,entered=new Set,ended=new Set,boundaryIds=new Set;let time=0;for(const[i,boundary]of snapshot.events.entries()){if(!boundary||typeof boundary.id!="string"||!boundary.id||bodies.has(boundary.id)||contextIds.has(boundary.id)||boundaryIds.has(boundary.id)||boundary.executionId!==executionId||boundary.scopeId!==executionId||!boundary.value||boundary.value.scope!=="work"||!["call","return","throw"].includes(boundary.value.type)||typeof boundary.occurredAt!="string"||!Number.isFinite(Date.parse(boundary.occurredAt))||!bodies.has(boundary.callId)||boundary.sequence!==i+1||!Number.isFinite(boundary.offsetMs)||boundary.offsetMs<time)return fail();boundaryIds.add(boundary.id),time=boundary.offsetMs;const parentId=parents.get(boundary.callId);if(boundary.value.type==="call"){if(entered.has(boundary.callId)||parentId!==void 0&&(!active.has(executionId)||!active.has(parentId))||boundary.callId===executionId&&i!==0)return fail();entered.add(boundary.callId),active.add(boundary.callId)}else{const body=bodies.get(boundary.callId);if(!["return","throw"].includes(boundary.value.type)||!active.has(boundary.callId)||[...active].some(id=>id!==boundary.callId&&(boundary.callId===executionId||parents.get(id)===boundary.callId))||!(boundary.value.type==="return"?hasOutput(body):Object.hasOwn(body,"error"))||statuses.get(boundary.callId)!==(boundary.value.type==="return"?"succeeded":"failed"))return fail();active.delete(boundary.callId),ended.add(boundary.callId)}}if(!historical&&entered.size!==bodies.size)return fail();for(const[id,body]of bodies)if(!historical&&!ended.has(id)&&(statuses.get(id)!=="running"||hasOutput(body)||Object.hasOwn(body,"error"))||historical&&!validRecordedStatus(statuses.get(id),body))return fail();if(!Array.isArray(snapshot.runtimeEvents)||!validRuntimeCallBoundaries(snapshot.runtimeEvents,runtimeCall.id,runtimeCall.status,runtimeCall.value,historical))return fail();for(const boundary of snapshot.runtimeEvents){if(boundaryIds.has(boundary.id)||observedBodies.has(boundary.id)||contextIds.has(boundary.id))return fail();boundaryIds.add(boundary.id)}const resourceIds=new Set,resourceSequences=new Map,accesses=new Map,interactions=new Map;for(const resourceRecord of snapshot.resources){if(!resourceRecord||typeof resourceRecord.id!="string"||!resourceRecord.id||bodies.has(resourceRecord.id)||contextIds.has(resourceRecord.id)||boundaryIds.has(resourceRecord.id)||resourceIds.has(resourceRecord.id)||typeof resourceRecord.parentId!="string"||!observedBodies.has(resourceRecord.parentId)||typeof resourceRecord.access!="string"||!resourceRecord.access||typeof resourceRecord.supplyId!="string"||!resourceRecord.supplyId||typeof resourceRecord.occurredAt!="string"||!Number.isFinite(Date.parse(resourceRecord.occurredAt))||!Object.hasOwn(resourceRecord,"value")||!Number.isSafeInteger(resourceRecord.sequence)||resourceRecord.sequence<=(resourceSequences.get(resourceRecord.parentId)??0))return fail();resourceSequences.set(resourceRecord.parentId,resourceRecord.sequence),resourceIds.add(resourceRecord.id);const accessKey=JSON.stringify([resourceRecord.parentId,resourceRecord.supplyId,resourceRecord.access]);if(resourceRecord.phase==="bound"){if(accesses.has(accessKey)||resourceRecord.interactionId!==void 0)return fail();accesses.set(accessKey,"bound")}else if(resourceRecord.phase==="available"||resourceRecord.phase==="unavailable"){if(accesses.get(accessKey)!=="bound"||resourceRecord.interactionId!==void 0)return fail();accesses.set(accessKey,resourceRecord.phase)}else if(resourceRecord.phase==="started"){if(accesses.get(accessKey)!=="available"||typeof resourceRecord.interactionId!="string"||!resourceRecord.interactionId||interactions.has(resourceRecord.interactionId))return fail();interactions.set(resourceRecord.interactionId,accessKey)}else if(resourceRecord.phase==="returned"||resourceRecord.phase==="threw"){if(typeof resourceRecord.interactionId!="string"||interactions.get(resourceRecord.interactionId)!==accessKey)return fail();interactions.delete(resourceRecord.interactionId)}else return fail()}}__name(validateLegacyExecutionRecordSnapshot,"validateLegacyExecutionRecordSnapshot");function validFailure(value){if(!value||typeof value!="object")return!1;const failure=value;return(failure.kind==="exception"||failure.kind==="error")&&typeof failure.contextId=="string"&&failure.contextId.length>0&&["setup","execute","receive","handling","control","observation"].includes(failure.phase)&&(failure.contract===void 0||typeof failure.contract=="string")}__name(validFailure,"validFailure");function validRelations(body,ownerContextId){const relations=new Map,eventSequences=new Set(body.processes.map(process=>process.eventSequence));let previous=0;for(const entry of body.relationChanges){if(!entry||!Number.isSafeInteger(entry.eventSequence)||entry.eventSequence<=previous||eventSequences.has(entry.eventSequence)||!Number.isFinite(entry.offsetMs)||entry.offsetMs<0||typeof entry.occurredAt!="string"||!Number.isFinite(Date.parse(entry.occurredAt))||!entry.identity||!entry.change)return!1;const identity=entry.identity;if(identity.parentContextId!==ownerContextId||typeof identity.childContextId!="string"||!identity.childContextId||identity.childContextId===ownerContextId||!Number.isSafeInteger(identity.parentRound)||identity.parentRound<0||identity.parentRound>2||identity.key!==void 0&&typeof identity.key!="string"||entry.childId!==void 0&&(typeof entry.childId!="string"||!entry.childId))return!1;const old=relations.get(identity.childContextId);if(old&&(old.identity.parentRound!==identity.parentRound||old.identity.key!==identity.key))return!1;const change=entry.change;if(change.kind==="attached"){if(old)return!1;relations.set(identity.childContextId,{identity,phase:"attached"})}else if(change.kind==="returned"){if(old?.phase!=="attached"||!change.result||!["succeeded","failed"].includes(change.result.status)||(change.result.status==="succeeded"?!Object.hasOwn(change.result,"output"):!validError(change.result.error)||change.result.failure!==void 0&&!validFailure(change.result.failure)))return!1;relations.set(identity.childContextId,{identity,phase:"returned",status:change.result.status})}else if(change.kind==="receiving"){if(old?.phase!=="returned")return!1;relations.set(identity.childContextId,{...old,phase:"receiving"})}else if(change.kind==="accepted"){if(old?.phase!=="receiving"||old.status!=="succeeded"||!Object.hasOwn(change,"output"))return!1;relations.set(identity.childContextId,{...old,phase:"accepted"})}else if(change.kind==="handled"){if(old?.phase!=="receiving"||old.status!=="failed"||!Object.hasOwn(change,"output"))return!1;relations.set(identity.childContextId,{...old,phase:"handled"})}else if(change.kind==="failed"){if(old?.phase!=="receiving"||!validError(change.error)||!["work","observation"].includes(change.source)||change.failure!==void 0&&!validFailure(change.failure))return!1;relations.set(identity.childContextId,{...old,phase:"failed"})}else return!1;eventSequences.add(entry.eventSequence),previous=entry.eventSequence}const times=[...body.processes,...body.relationChanges].sort((a,b)=>a.eventSequence-b.eventSequence);return times.every((entry,index)=>index===0||entry.offsetMs>=times[index-1].offsetMs)}__name(validRelations,"validRelations");function validError(value){return!!value&&typeof value=="object"&&typeof value.code=="string"&&typeof value.message=="string"}__name(validError,"validError");function validRuntimeCallBoundaries(boundaries,id,status,value,historical=!1){if(!historical&&boundaries.length<1||boundaries.length>2)return!1;for(const[index,boundary]of boundaries.entries())if(!boundary||!boundary.id||boundary.scopeId!==id||boundary.executionId!==void 0||boundary.callId!==id||boundary.parentId!==id||boundary.sequence!==index+1||!Number.isFinite(boundary.offsetMs)||boundary.offsetMs<(boundaries[index-1]?.offsetMs??0)||!Number.isFinite(Date.parse(boundary.occurredAt))||boundary.value?.scope!=="work"||boundary.value.type!==(index===0?"call":status==="succeeded"?"return":"throw"))return!1;return historical&&boundaries.length<2?validRecordedStatus(status,value):status==="running"?boundaries.length===1:boundaries.length===2&&(status==="succeeded"?hasOutput(value):Object.hasOwn(value,"error"))}__name(validRuntimeCallBoundaries,"validRuntimeCallBoundaries");function validateInvocationRecordValue(value,ownerContextId){const fail=__name(()=>{throw new Error("\u8C03\u7528\u8BB0\u5F55\u6B63\u6587\u65E0\u6548\u3002")},"fail"),body=value;if(!body||!Array.isArray(body.processes)||!Array.isArray(body.relationChanges)||typeof body!="object"||!Object.hasOwn(body,"input")||hasOutput(body)&&Object.hasOwn(body,"error")||Object.hasOwn(body,"output")&&Object.hasOwn(body,"resultOf")||Object.hasOwn(body,"error")&&(!body.error||typeof body.error.code!="string"||typeof body.error.message!="string")||body.failure&&(!Object.hasOwn(body,"error")||!validFailure(body.failure)))return fail();let previousRound=0,previousTime=0,previousSequence=0;for(const[index,process]of body.processes.entries()){if(!process||!Number.isSafeInteger(process.eventSequence)||process.eventSequence<=previousSequence||process.sequence!==index+1||!Number.isInteger(process.round)||process.round<previousRound||process.round>2||!Number.isFinite(process.offsetMs)||process.offsetMs<previousTime||typeof process.occurredAt!="string"||!(process.stage==="execute"?["start","return","throw"]:process.stage==="receive"?["return","throw","continue"]:process.stage==="handling"?["start","return","throw","continue","unhandled"]:process.stage==="control"?["stop"]:[]).includes(process.type)||process.round===0&&process.stage!=="control"||(process.stage==="execute"&&process.type==="start"||process.type==="continue")&&!Object.hasOwn(process,"input")||process.type==="return"&&Object.hasOwn(process,"output")===Object.hasOwn(process,"resultOf"))return fail();if("resultOf"in process)try{const target=outputProcess(body,process.resultOf,process.sequence);if(process.stage!=="receive"||target.stage!=="execute"||target.round!==process.round||target.sequence!==process.sequence-1)return fail()}catch{return fail()}if((process.type==="throw"||process.type==="stop"||process.stage==="handling"&&(process.type==="start"||process.type==="unhandled"))&&(!process.error||typeof process.error.code!="string"||typeof process.error.message!="string")||process.type==="continue"&&(typeof process.reason!="string"||!process.reason.trim())||"failure"in process&&process.failure&&!validFailure(process.failure))return fail();previousRound=process.round,previousTime=process.offsetMs,previousSequence=process.eventSequence}if(!validRelations(body,ownerContextId))return fail();if(Object.hasOwn(body,"resultOf"))try{readOutput(body)}catch{return fail()}}__name(validateInvocationRecordValue,"validateInvocationRecordValue");function validRecordedStatus(status,body){return status==="running"?!hasOutput(body)&&!Object.hasOwn(body,"error"):status==="succeeded"?hasOutput(body)&&!Object.hasOwn(body,"error"):status==="failed"&&Object.hasOwn(body,"error")&&!hasOutput(body)}__name(validRecordedStatus,"validRecordedStatus");export{validateExecutionRecordSnapshot,validateInvocationRecordValue,validateLegacyExecutionRecordSnapshot};

package/dist/execution/helper.d.ts

@@ -1,6 +1,6 @@
 import type { InvocationFailureFact, RuntimeErrorValue } from '@weiliang0121/capix-contracts';
 import type { Recorder } from '../recorder.js';
-import type { ExecutionValue, LegacyExecutionRecordSnapshot } from '@weiliang0121/capix-protocol';
+import type { ExecutionValue, LegacyExecutionRecordSnapshot } from '../data/index.js';
 import type { RecordBook } from '../book.js';
 import { ExecutionRecord } from './record.js';
 export declare class ExecutionRecordHelper {

package/dist/execution/record.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionRecord as ExecutionData, ExecutionValue } from '@weiliang0121/capix-protocol';
+import type { ExecutionRecord as ExecutionData, ExecutionValue } from '../data/index.js';
 import { InvocationRecord } from '../invocation/record.js';
 export declare class ExecutionRecord extends InvocationRecord<ExecutionValue> implements ExecutionData {
     readonly contextId: string;

package/dist/index.d.ts

@@ -28,3 +28,4 @@ export { snapshotValue } from './value/snapshot.js';
 export type { RecordChangeSource } from './source.js';
 export { RecordingError, writeRecord } from './error.js';
 export { RecordResource, type RecordReader, type RecordCreator } from './resource.js';
+export { transcriptRecord, memoryRecord, recordContentFact } from './content.js';

package/dist/index.js

@@ -1,2 +1,2 @@
 /*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
-import{CallableRecord}from"./callable/record.js";import{CallableRecordHelper}from"./callable/helper.js";import{BaseRecord}from"./record.js";import{CompositeRecord}from"./composite.js";import{InvocationRecord}from"./invocation/record.js";import{InvocationRecordHelper}from"./invocation/helper.js";import{RecordingRootRecord}from"./root/record.js";import{RecordingRootHelper}from"./root/helper.js";import{ExecutionRecord}from"./execution/record.js";import{ExecutionRecordHelper}from"./execution/helper.js";import{OperationRecord}from"./operation/record.js";import{OperationRecordHelper}from"./operation/helper.js";import{AttemptRecord}from"./attempt/record.js";import{AttemptRecordHelper}from"./attempt/helper.js";import{RecordBook}from"./book.js";import{InvocationBoundaryRecord}from"./invocation/boundary/record.js";import{InvocationBoundaryRecordHelper}from"./invocation/boundary/helper.js";import{MemoryRecord}from"./memory/record.js";import{MemoryRecordHelper}from"./memory/helper.js";import{observeMemory}from"./memory/observe.js";import{TranscriptRecord}from"./transcript/record.js";import{TranscriptRecordHelper}from"./transcript/helper.js";import{RecordTree}from"./tree/tree.js";import{ResourceRecord}from"./resource/record.js";import{RuntimeCallRecord}from"./runtime/record.js";import{Recorder}from"./recorder.js";import{snapshotValue}from"./value/snapshot.js";import{RecordingError,writeRecord}from"./error.js";import{RecordResource}from"./resource.js";export{AttemptRecord,AttemptRecordHelper,BaseRecord,CallableRecord,CallableRecordHelper,CompositeRecord,ExecutionRecord,ExecutionRecordHelper,InvocationBoundaryRecord,InvocationBoundaryRecordHelper,InvocationRecord,InvocationRecordHelper,MemoryRecord,MemoryRecordHelper,OperationRecord,OperationRecordHelper,RecordBook,RecordResource,RecordTree,Recorder,RecordingError,RecordingRootHelper,RecordingRootRecord,ResourceRecord,RuntimeCallRecord,TranscriptRecord,TranscriptRecordHelper,observeMemory,snapshotValue,writeRecord};
+import{CallableRecord}from"./callable/record.js";import{CallableRecordHelper}from"./callable/helper.js";import{BaseRecord}from"./record.js";import{CompositeRecord}from"./composite.js";import{InvocationRecord}from"./invocation/record.js";import{InvocationRecordHelper}from"./invocation/helper.js";import{RecordingRootRecord}from"./root/record.js";import{RecordingRootHelper}from"./root/helper.js";import{ExecutionRecord}from"./execution/record.js";import{ExecutionRecordHelper}from"./execution/helper.js";import{OperationRecord}from"./operation/record.js";import{OperationRecordHelper}from"./operation/helper.js";import{AttemptRecord}from"./attempt/record.js";import{AttemptRecordHelper}from"./attempt/helper.js";import{RecordBook}from"./book.js";import{InvocationBoundaryRecord}from"./invocation/boundary/record.js";import{InvocationBoundaryRecordHelper}from"./invocation/boundary/helper.js";import{MemoryRecord}from"./memory/record.js";import{MemoryRecordHelper}from"./memory/helper.js";import{observeMemory}from"./memory/observe.js";import{TranscriptRecord}from"./transcript/record.js";import{TranscriptRecordHelper}from"./transcript/helper.js";import{RecordTree}from"./tree/tree.js";import{ResourceRecord}from"./resource/record.js";import{RuntimeCallRecord}from"./runtime/record.js";import{Recorder}from"./recorder.js";import{snapshotValue}from"./value/snapshot.js";import{RecordingError,writeRecord}from"./error.js";import{RecordResource}from"./resource.js";import{transcriptRecord,memoryRecord,recordContentFact}from"./content.js";export{AttemptRecord,AttemptRecordHelper,BaseRecord,CallableRecord,CallableRecordHelper,CompositeRecord,ExecutionRecord,ExecutionRecordHelper,InvocationBoundaryRecord,InvocationBoundaryRecordHelper,InvocationRecord,InvocationRecordHelper,MemoryRecord,MemoryRecordHelper,OperationRecord,OperationRecordHelper,RecordBook,RecordResource,RecordTree,Recorder,RecordingError,RecordingRootHelper,RecordingRootRecord,ResourceRecord,RuntimeCallRecord,TranscriptRecord,TranscriptRecordHelper,memoryRecord,observeMemory,recordContentFact,snapshotValue,transcriptRecord,writeRecord};

package/dist/invocation/boundary/helper.d.ts

@@ -1,4 +1,4 @@
-import type { InvocationBoundaryValue } from '@weiliang0121/capix-protocol';
+import type { InvocationBoundaryValue } from '../../data/index.js';
 import type { Recorder } from '../../recorder.js';
 import type { RecordBook } from '../../book.js';
 import { InvocationBoundaryRecord } from './record.js';

package/dist/invocation/boundary/record.d.ts

@@ -1,4 +1,4 @@
-import type { InvocationBoundaryRecord as BoundaryData, InvocationBoundaryValue } from '@weiliang0121/capix-protocol';
+import type { InvocationBoundaryRecord as BoundaryData, InvocationBoundaryValue } from '../../data/index.js';
 import { BaseRecord } from '../../record.js';
 export type InvocationBoundaryRecordOptions = Omit<BoundaryData, 'id' | 'value' | 'parentId' | 'scopeId'> & {
     readonly scopeId?: string;

package/dist/invocation/record.d.ts

@@ -3,14 +3,14 @@ import type { RuntimeCallRecord } from '../runtime/record.js';
 import type { ExecutionRecord } from '../execution/record.js';
 import type { OperationRecord } from '../operation/record.js';
 import type { AttemptRecord } from '../attempt/record.js';
-import { type InvocationValue, type ProcessRecord, type RelationChangeRecord } from '@weiliang0121/capix-protocol';
+import { type InvocationValue, type ProcessRecord, type RelationChangeRecord } from '../data/index.js';
 import type { RuntimeErrorValue, InvocationFailureFact } from '@weiliang0121/capix-contracts';
 import { CompositeRecord } from '../composite.js';
 import { restoreStatus } from '../restoration/access.js';
 export type ConcreteInvocationRecord = CallableRecord | RuntimeCallRecord | ExecutionRecord | OperationRecord | AttemptRecord;
 export declare class InvocationRecord<Value extends InvocationValue> extends CompositeRecord<Value> {
     #private;
-    get status(): "running" | "succeeded" | "failed";
+    get status(): "succeeded" | "failed" | "running";
     protected requireRunning(): void;
     [restoreStatus](status: 'running' | 'succeeded' | 'failed'): void;
     append(process: ProcessRecord): void;

package/dist/invocation/record.js

@@ -1,2 +1,2 @@
 /*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
-var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{outputProcess,finalOutputProcess}from"@weiliang0121/capix-protocol";import{CompositeRecord}from"../composite.js";import{isUndefined}from"es-toolkit/predicate";import{snapshotValue}from"../value/snapshot.js";import{restoreStatus}from"../restoration/access.js";class InvocationRecord extends CompositeRecord{static{__name(this,"InvocationRecord")}#status="running";get status(){return this.#status}requireRunning(){if(this.requireWritable(),this.#status!=="running")throw new Error("Record has already ended")}[restoreStatus](status){this.requireWritable(),this.#status=status}append(process){if(this.requireRunning(),process.sequence!==this.value.processes.length+1)throw new Error("Process sequence must advance in order");if("resultOf"in process){if(Object.hasOwn(process,"output"))throw new Error("Output and local result reference are mutually exclusive");const target=outputProcess(this.value,process.resultOf,process.sequence);if(process.stage!=="receive"||target.stage!=="execute"||target.round!==process.round||target.sequence!==process.sequence-1)throw new Error("Receive may only reuse its own execution result")}const captured=snapshotValue(process);this.replaceValue(Object.freeze({...this.value,processes:Object.freeze([...this.value.processes,captured])}))}appendRelation(relation){if(this.requireRunning(),!Number.isSafeInteger(relation.eventSequence)||relation.eventSequence<1)throw new Error("Relation fact requires an event sequence");const last=this.value.relationChanges.at(-1);if(last&&relation.eventSequence<=last.eventSequence)throw new Error("Relation fact sequence must advance");const captured=snapshotValue(relation);this.replaceValue(Object.freeze({...this.value,relationChanges:Object.freeze([...this.value.relationChanges,captured])}))}complete(output,resultOf){this.requireRunning(),isUndefined(resultOf)?this.replaceValue(Object.freeze({...this.value,output:snapshotValue(output)})):(finalOutputProcess(this.value,resultOf),this.replaceValue(Object.freeze({...this.value,resultOf}))),this.#status="succeeded"}fail(error,failure){this.requireRunning(),this.replaceValue(Object.freeze({...this.value,error:snapshotValue(error),...failure?{failure:snapshotValue(failure)}:{}})),this.#status="failed"}}export{InvocationRecord};
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{outputProcess,finalOutputProcess}from"../data/index.js";import{CompositeRecord}from"../composite.js";import{isUndefined}from"es-toolkit/predicate";import{snapshotValue}from"../value/snapshot.js";import{restoreStatus}from"../restoration/access.js";class InvocationRecord extends CompositeRecord{static{__name(this,"InvocationRecord")}#status="running";get status(){return this.#status}requireRunning(){if(this.requireWritable(),this.#status!=="running")throw new Error("Record has already ended")}[restoreStatus](status){this.requireWritable(),this.#status=status}append(process){if(this.requireRunning(),process.sequence!==this.value.processes.length+1)throw new Error("Process sequence must advance in order");if("resultOf"in process){if(Object.hasOwn(process,"output"))throw new Error("Output and local result reference are mutually exclusive");const target=outputProcess(this.value,process.resultOf,process.sequence);if(process.stage!=="receive"||target.stage!=="execute"||target.round!==process.round||target.sequence!==process.sequence-1)throw new Error("Receive may only reuse its own execution result")}const captured=snapshotValue(process);this.replaceValue(Object.freeze({...this.value,processes:Object.freeze([...this.value.processes,captured])}))}appendRelation(relation){if(this.requireRunning(),!Number.isSafeInteger(relation.eventSequence)||relation.eventSequence<1)throw new Error("Relation fact requires an event sequence");const last=this.value.relationChanges.at(-1);if(last&&relation.eventSequence<=last.eventSequence)throw new Error("Relation fact sequence must advance");const captured=snapshotValue(relation);this.replaceValue(Object.freeze({...this.value,relationChanges:Object.freeze([...this.value.relationChanges,captured])}))}complete(output,resultOf){this.requireRunning(),isUndefined(resultOf)?this.replaceValue(Object.freeze({...this.value,output:snapshotValue(output)})):(finalOutputProcess(this.value,resultOf),this.replaceValue(Object.freeze({...this.value,resultOf}))),this.#status="succeeded"}fail(error,failure){this.requireRunning(),this.replaceValue(Object.freeze({...this.value,error:snapshotValue(error),...failure?{failure:snapshotValue(failure)}:{}})),this.#status="failed"}}export{InvocationRecord};

package/dist/memory/helper.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryRecordValue } from '@weiliang0121/capix-protocol';
+import type { MemoryRecordValue } from '../data/index.js';
 import type { RecordBook } from '../book.js';
 import { MemoryRecord, type MemoryRecordOptions } from './record.js';
 export declare class MemoryRecordHelper {

package/dist/memory/observe.d.ts

@@ -1,10 +1,9 @@
-import type { MemoryContent, MemoryObservation } from '@weiliang0121/capix-protocol';
+import type { MemoryRecordContent, MemoryRecordObservation } from '../data/index.js';
 import type { RecordBook } from '../book.js';
 export declare function observeMemory(collection: {
-    readonly transcript: {
+    readonly id: string;
+    values(): readonly {
         readonly id: string;
-    };
-    values(): readonly (MemoryContent & {
-        readonly id: string;
-    })[];
-}, book: RecordBook): MemoryObservation;
+        readonly value: MemoryRecordContent;
+    }[];
+}, book: RecordBook): MemoryRecordObservation;

package/dist/memory/observe.js

@@ -1,2 +1,2 @@
 /*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
-var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{MemoryRecord}from"./record.js";function observeMemory(collection,book){const records=new Map;for(const record of book.values()){if(!(record instanceof MemoryRecord))continue;const own=records.get(record.memoryId);own?own.push(record):records.set(record.memoryId,[record])}return{items:collection.values().map(memory=>({id:memory.id,topic:memory.topic,content:memory.content,sources:memory.sourceIndexes.map(index=>({transcriptId:collection.transcript.id,index})),...memory.sourceResults?{sourceResults:memory.sourceResults}:{},records:(records.get(memory.id)??[]).map(record=>record.toJSON())}))}}__name(observeMemory,"observeMemory");export{observeMemory};
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{MemoryRecord}from"./record.js";function observeMemory(collection,book){const records=new Map;for(const record of book.values()){if(!(record instanceof MemoryRecord)||record.memoriesId!==collection.id)continue;const own=records.get(record.memoryId);own?own.push(record):records.set(record.memoryId,[record])}return{items:collection.values().map(memory=>({id:memory.id,value:{content:memory.value.content},records:(records.get(memory.id)??[]).map(record=>record.toJSON())}))}}__name(observeMemory,"observeMemory");export{observeMemory};

package/dist/memory/record.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryRecord as MemoryRecordData, MemoryRecordValue } from '@weiliang0121/capix-protocol';
+import { type MemoryRecord as MemoryRecordData, type MemoryRecordValue } from '../data/index.js';
 import type { RecordChangeSource } from '../source.js';
 import { BaseRecord } from '../record.js';
 export interface MemoryRecordOptions {

package/dist/memory/record.js

@@ -1,2 +1,2 @@
 /*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
-var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{isSafeInteger}from"es-toolkit/compat";import{isString,isUndefined}from"es-toolkit/predicate";import{pick,omitBy}from"es-toolkit/object";import{BaseRecord}from"../record.js";import{snapshotValue}from"../value/snapshot.js";class MemoryRecord extends BaseRecord{static{__name(this,"MemoryRecord")}kind="memory";memoryId;memoriesId;sequence;executionId;operationId;contextId;callId;constructor(options,value){if(super(snapshotValue(value),options.source?.callId),!isString(options.memoriesId)||!/\S/u.test(options.memoriesId)||!isSafeInteger(options.sequence)||options.sequence<1)throw new Error("Memory change requires a scope and a positive sequence");this.memoryId=options.memoryId,this.memoriesId=options.memoriesId,this.sequence=options.sequence,this.executionId=options.source?.executionId,this.operationId=options.source?.operationId,this.contextId=options.source?.contextId,this.callId=options.source?.callId,Object.freeze(this)}toJSON(){return{...super.toJSON(),...pick(this,["memoryId","memoriesId","sequence"]),...omitBy(pick(this,["executionId","operationId","contextId","callId"]),isUndefined)}}}export{MemoryRecord};
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{isSafeInteger}from"es-toolkit/compat";import{isString,isUndefined}from"es-toolkit/predicate";import{pick,omitBy}from"es-toolkit/object";import{validateMemoryRecordValue}from"../data/index.js";import{BaseRecord}from"../record.js";import{snapshotValue}from"../value/snapshot.js";class MemoryRecord extends BaseRecord{static{__name(this,"MemoryRecord")}kind="memory";memoryId;memoriesId;sequence;executionId;operationId;contextId;callId;constructor(options,value){if(super(snapshotValue(value),options.source?.callId),validateMemoryRecordValue(this.value),!isString(options.memoriesId)||!/\S/u.test(options.memoriesId)||!isSafeInteger(options.sequence)||options.sequence<1)throw new Error("Memory change requires a scope and a positive sequence");this.memoryId=options.memoryId,this.memoriesId=options.memoriesId,this.sequence=options.sequence,this.executionId=options.source?.executionId,this.operationId=options.source?.operationId,this.contextId=options.source?.contextId,this.callId=options.source?.callId,Object.freeze(this)}toJSON(){return{...super.toJSON(),...pick(this,["memoryId","memoriesId","sequence"]),...omitBy(pick(this,["executionId","operationId","contextId","callId"]),isUndefined)}}}export{MemoryRecord};

package/dist/operation/record.d.ts

@@ -1,4 +1,4 @@
-import type { OperationRecord as OperationData, InvocationValue } from '@weiliang0121/capix-protocol';
+import type { OperationRecord as OperationData, InvocationValue } from '../data/index.js';
 import { InvocationRecord } from '../invocation/record.js';
 export type OperationRecordOptions = Omit<OperationData, 'id' | 'value' | 'status' | 'parentId' | 'childIds'>;
 export declare class OperationRecord extends InvocationRecord<InvocationValue> implements OperationData {

package/dist/record.d.ts

@@ -1,4 +1,4 @@
-import type { RecordKind, BaseRecord as RecordData } from '@weiliang0121/capix-protocol';
+import type { RecordKind, BaseRecord as RecordData } from './data/index.js';
 import { restoreContent, sealHistorical } from './restoration/access.js';
 export declare abstract class BaseRecord<Value> implements RecordData<Value> {
     #private;

package/dist/recorder.d.ts

@@ -1,4 +1,4 @@
-import type { RecordChangeEvent, RecordMutation } from '@weiliang0121/capix-protocol';
+import type { RecordChangeEvent, RecordMutation } from './data/index.js';
 import type { ChangeCapture } from '@weiliang0121/capix-changes';
 import { RecordBook } from './book.js';
 import type { BaseRecord } from './record.js';

package/dist/resource/record.d.ts

@@ -1,4 +1,4 @@
-import type { ResourceRecord as ResourceRecordData } from '@weiliang0121/capix-protocol';
+import type { ResourceRecord as ResourceRecordData } from '../data/index.js';
 import { BaseRecord } from '../record.js';
 export type ResourceRecordOptions = Omit<ResourceRecordData, 'id' | 'value'>;
 export declare class ResourceRecord<Detail = unknown> extends BaseRecord<Detail> implements ResourceRecordData<Detail> {

package/dist/resource.d.ts

@@ -1,5 +1,5 @@
 import { ResourceOffer } from '@weiliang0121/capix-resources';
-import type { RecordEntry } from '@weiliang0121/capix-protocol';
+import type { RecordEntry } from './data/index.js';
 import type { RecordBookState } from './book.js';
 import type { Recorder } from './recorder.js';
 export interface RecordReader {

package/dist/restoration/check.d.ts

@@ -1,2 +1,2 @@
-import { type RecordEntry } from '@weiliang0121/capix-protocol';
+import { type RecordEntry } from '../data/index.js';
 export declare function checkEntry(entry: RecordEntry): void;

package/dist/restoration/check.js

@@ -1,2 +1,2 @@
 /*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
-var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{hasOutput,validateInvocationRecordValue}from"@weiliang0121/capix-protocol";import{isPlainObject}from"es-toolkit/predicate";function fail(){throw new Error("Invalid stored record")}__name(fail,"fail");function object(value){return isPlainObject(value)?value:fail()}__name(object,"object");function text(value){(typeof value!="string"||!value.trim())&&fail()}__name(text,"text");function optionalText(value){value!==void 0&&text(value)}__name(optionalText,"optionalText");function integer(value,minimum=0){(typeof value!="number"||!Number.isSafeInteger(value)||value<minimum)&&fail()}__name(integer,"integer");function time(value){text(value),Number.isFinite(Date.parse(value))||fail()}__name(time,"time");function indexes(value,nonempty=!0){(!Array.isArray(value)||nonempty&&!value.length||new Set(value).size!==value.length)&&fail();for(const index of value)integer(index)}__name(indexes,"indexes");function sources(value){if(value===void 0)return;Array.isArray(value)||fail();const ids=new Set;for(const item of value){const source=object(item);text(source.id),(ids.has(source.id)||source.kind!=="file-created")&&fail(),ids.add(source.id),integer(source.answerIndex);const receipt=object(source.receipt);text(receipt.path),integer(receipt.bytes),(typeof receipt.digest!="string"||!/^[a-f0-9]{64}$/u.test(receipt.digest))&&fail()}}__name(sources,"sources");function children(value){(!Array.isArray(value)||new Set(value).size!==value.length)&&fail();for(const id of value)text(id)}__name(children,"children");function checkEntry(entry){const outer=object(entry);(Object.keys(outer).length!==2||!Object.hasOwn(outer,"kind")||!Object.hasOwn(outer,"data"))&&fail();const data=object(outer.data);if(text(data.id),optionalText(data.parentId),Object.hasOwn(data,"value")||fail(),["invocation","runtime","runtime-call","execution","operation","attempt"].includes(entry.kind)&&children(data.childIds),["invocation","runtime-call","execution","operation","attempt"].includes(entry.kind)){text(data.parentId),text(data.contextId),data.contextId===data.id&&fail(),validateInvocationRecordValue(data.value,data.contextId);const output=hasOutput(data.value),error=Object.hasOwn(data.value,"error");(data.status==="running"?output||error:data.status==="succeeded"?!output||error:data.status!=="failed"||!error||output)&&fail()}switch(entry.kind){case"invocation":["scene","group","node"].includes(data.structureKind)||fail();for(const name of["structureId","name","label","callee","role"])optionalText(data[name]);data.source!==void 0&&typeof data.source!="string"&&fail(),time(object(data.value).startedAt);break;case"runtime":time(object(data.value).createdAt);break;case"runtime-call":text(data.runtimeInstanceId),time(object(data.value).startedAt);break;case"execution":time(object(data.value).startedAt);break;case"operation":for(const name of["executionId","operationInstanceId","operation","label","caller","callee"])text(data[name]);typeof data.source!="string"&&fail(),optionalText(data.parentOperationId);break;case"attempt":for(const name of["operationId","name","label","caller","callee"])text(data[name]);typeof data.source!="string"&&fail();break;case"invocation-boundary":{text(data.scopeId),text(data.callId),optionalText(data.executionId),integer(data.sequence,1),time(data.occurredAt),(typeof data.offsetMs!="number"||!Number.isFinite(data.offsetMs)||data.offsetMs<0)&&fail();const value=object(data.value);(value.scope!=="work"||!["call","return","throw"].includes(value.type))&&fail();break}case"resource":for(const name of["parentId","access","supplyId"])text(data[name]);integer(data.sequence,1),time(data.occurredAt),["bound","available","unavailable","started","returned","threw"].includes(data.phase)||fail(),["started","returned","threw"].includes(data.phase)?text(data.interactionId):data.interactionId!==void 0&&fail();break;case"transcript":{text(data.transcriptId),integer(data.revision,1),time(data.occurredAt);const value=object(data.value);integer(value.start),integer(value.end),value.action==="append"?value.end<=value.start&&fail():value.action==="segment"?(integer(value.previousStart),(value.previousStart>=value.start||value.start>=value.end)&&fail()):fail(),checkContentSource(data);break}case"memory":{text(data.memoryId),text(data.memoriesId),integer(data.sequence,1),optionalText(data.operationId),checkContentSource(data);const value=object(data.value);value.action!=="create"&&value.action!=="update"&&fail(),text(value.change),indexes(value.sourceIndexes),sources(value.sourceResults);const result=object(value.result);text(result.topic),text(result.content),indexes(result.sourceIndexes),sources(result.sourceResults);break}case"custom":Object.hasOwn(data,"childIds")&&children(data.childIds);break;default:fail()}}__name(checkEntry,"checkEntry");function checkContentSource(data){optionalText(data.callId),optionalText(data.contextId),optionalText(data.executionId),data.callId===void 0!=(data.contextId===void 0)&&fail()}__name(checkContentSource,"checkContentSource");export{checkEntry};
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{hasOutput,validateInvocationRecordValue,validateMemoryRecordValue}from"../data/index.js";import{isPlainObject}from"es-toolkit/predicate";function fail(){throw new Error("Invalid stored record")}__name(fail,"fail");function object(value){return isPlainObject(value)?value:fail()}__name(object,"object");function text(value){(typeof value!="string"||!value.trim())&&fail()}__name(text,"text");function optionalText(value){value!==void 0&&text(value)}__name(optionalText,"optionalText");function integer(value,minimum=0){(typeof value!="number"||!Number.isSafeInteger(value)||value<minimum)&&fail()}__name(integer,"integer");function time(value){text(value),Number.isFinite(Date.parse(value))||fail()}__name(time,"time");function children(value){(!Array.isArray(value)||new Set(value).size!==value.length)&&fail();for(const id of value)text(id)}__name(children,"children");function checkEntry(entry){const outer=object(entry);(Object.keys(outer).length!==2||!Object.hasOwn(outer,"kind")||!Object.hasOwn(outer,"data"))&&fail();const data=object(outer.data);if(text(data.id),optionalText(data.parentId),Object.hasOwn(data,"value")||fail(),["invocation","runtime","runtime-call","execution","operation","attempt"].includes(entry.kind)&&children(data.childIds),["invocation","runtime-call","execution","operation","attempt"].includes(entry.kind)){text(data.parentId),text(data.contextId),data.contextId===data.id&&fail(),validateInvocationRecordValue(data.value,data.contextId);const output=hasOutput(data.value),error=Object.hasOwn(data.value,"error");(data.status==="running"?output||error:data.status==="succeeded"?!output||error:data.status!=="failed"||!error||output)&&fail()}switch(entry.kind){case"invocation":["scene","group","node"].includes(data.structureKind)||fail();for(const name of["structureId","name","label","callee","role"])optionalText(data[name]);data.source!==void 0&&typeof data.source!="string"&&fail(),time(object(data.value).startedAt);break;case"runtime":time(object(data.value).createdAt);break;case"runtime-call":text(data.runtimeInstanceId),time(object(data.value).startedAt);break;case"execution":time(object(data.value).startedAt);break;case"operation":for(const name of["executionId","operationInstanceId","operation","label","caller","callee"])text(data[name]);typeof data.source!="string"&&fail(),optionalText(data.parentOperationId);break;case"attempt":for(const name of["operationId","name","label","caller","callee"])text(data[name]);typeof data.source!="string"&&fail();break;case"invocation-boundary":{text(data.scopeId),text(data.callId),optionalText(data.executionId),integer(data.sequence,1),time(data.occurredAt),(typeof data.offsetMs!="number"||!Number.isFinite(data.offsetMs)||data.offsetMs<0)&&fail();const value=object(data.value);(value.scope!=="work"||!["call","return","throw"].includes(value.type))&&fail();break}case"resource":for(const name of["parentId","access","supplyId"])text(data[name]);integer(data.sequence,1),time(data.occurredAt),["bound","available","unavailable","started","returned","threw"].includes(data.phase)||fail(),["started","returned","threw"].includes(data.phase)?text(data.interactionId):data.interactionId!==void 0&&fail();break;case"transcript":{text(data.transcriptId),integer(data.revision,1),time(data.occurredAt);const value=object(data.value);integer(value.start),integer(value.end),value.action==="append"?value.end<=value.start&&fail():value.action==="segment"?(integer(value.previousStart),(value.previousStart>=value.start||value.start>=value.end)&&fail()):fail(),checkContentSource(data);break}case"memory":{text(data.memoryId),text(data.memoriesId),integer(data.sequence,1),optionalText(data.operationId),checkContentSource(data),validateMemoryRecordValue(data.value);break}case"custom":Object.hasOwn(data,"childIds")&&children(data.childIds);break;default:fail()}}__name(checkEntry,"checkEntry");function checkContentSource(data){optionalText(data.callId),optionalText(data.contextId),optionalText(data.executionId),data.callId===void 0!=(data.contextId===void 0)&&fail()}__name(checkContentSource,"checkContentSource");export{checkEntry};

package/dist/restoration/entry.d.ts

@@ -1,3 +1,3 @@
-import type { RecordEntry } from '@weiliang0121/capix-protocol';
+import type { RecordEntry } from '../data/index.js';
 import { BaseRecord } from '../record.js';
 export declare function restoreEntry(entry: RecordEntry): BaseRecord<unknown>;

package/dist/restoration/tree.js

@@ -1,2 +1,2 @@
 /*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
-var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{CallableRecord}from"../callable/record.js";import{CompositeRecord}from"../composite.js";import{InvocationRecord}from"../invocation/record.js";import{InvocationBoundaryRecord}from"../invocation/boundary/record.js";import{ResourceRecord}from"../resource/record.js";import{checkRelation}from"../tree/relation.js";function checkRestoredTree(book){const contexts=new Set,boundaries=new Map,resources=new Map;for(const record of book.values()){const parent=record.parentId===void 0?void 0:book.get(record.parentId);if(record.parentId!==void 0&&!(parent instanceof CompositeRecord))throw new Error("Stored record parent is missing or cannot contain children");if(parent instanceof CompositeRecord&&!parent.childIds.includes(record.id))throw new Error("Stored record parent does not reference its child");if(record instanceof CompositeRecord)for(const childId of record.childIds){const child=book.get(childId);if(!child||child.parentId!==record.id)throw new Error("Inconsistent stored child reference")}if(checkRelation(record,parent,book,"restore"),record instanceof InvocationRecord&&"contextId"in record){const contextId=record.contextId;if(contexts.has(contextId)||book.get(contextId))throw new Error("Stored invocation context identity conflicts");contexts.add(contextId);for(const relation of record.value.relationChanges){const child=relation.childId===void 0?void 0:book.get(relation.childId);if(child&&(child.parentId!==record.id||!("contextId"in child)||child.contextId!==relation.identity.childContextId))throw new Error("Stored child relation points to another invocation")}}if(record instanceof InvocationBoundaryRecord){const invocation=book.get(record.callId);if(invocation instanceof CallableRecord){let scope2=invocation;const parents=new Set([scope2.id]);let parent2=scope2.parentId?book.get(scope2.parentId):void 0;for(;parent2 instanceof CallableRecord;){if(parents.has(parent2.id))throw new Error("Stored callable ancestry contains a cycle");parents.add(parent2.id),scope2=parent2,parent2=scope2.parentId?book.get(scope2.parentId):void 0}if(record.scopeId!==scope2.id||record.executionId!==void 0)throw new Error("Stored callable boundary has an inconsistent timing scope")}else if(record.scopeId!==(record.executionId??record.callId))throw new Error("Stored boundary has an inconsistent timing scope");const scope=boundaries.get(record.scopeId)??{sequence:0,offsetMs:0,calls:new Map};if(record.sequence!==scope.sequence+1||record.offsetMs<scope.offsetMs)throw new Error("Stored boundary sequence does not advance");const prior=scope.calls.get(record.callId);if(record.value.type==="call"?prior!==void 0:prior!=="call")throw new Error("Stored boundary does not follow its call");const call=book.get(record.callId);if(record.value.type==="call"&&record.callId!==record.scopeId&&scope.calls.get(call.parentId)!=="call")throw new Error("Stored child boundary starts outside its parent work");if(record.value.type==="call"&&record.callId===record.scopeId&&record.sequence!==1)throw new Error("Stored work scope must start before its children");if(record.value.type!=="call"&&[...scope.calls].some(([id,state])=>state==="call"&&book.get(id)?.parentId===record.callId))throw new Error("Stored parent boundary ends before its active child");scope.sequence=record.sequence,scope.offsetMs=record.offsetMs,scope.calls.set(record.callId,record.value.type),boundaries.set(record.scopeId,scope)}if(record instanceof ResourceRecord){const scope=resources.get(record.parentId)??{sequence:0,accesses:new Map,interactions:new Map};if(record.sequence!==scope.sequence+1)throw new Error("Stored resource sequence does not advance");const key=JSON.stringify([record.supplyId,record.access]);if(record.phase==="bound"){if(scope.accesses.has(key))throw new Error("Stored resource access is already bound");scope.accesses.set(key,record.phase)}else if(record.phase==="available"||record.phase==="unavailable"){if(scope.accesses.get(key)!=="bound")throw new Error("Stored resource access is not bound");scope.accesses.set(key,record.phase)}else if(record.phase==="started"){if(scope.accesses.get(key)!=="available"||scope.interactions.has(record.interactionId))throw new Error("Stored resource interaction is not available");scope.interactions.set(record.interactionId,key)}else{if(scope.interactions.get(record.interactionId)!==key)throw new Error("Stored resource interaction has not started");scope.interactions.delete(record.interactionId)}scope.sequence=record.sequence,resources.set(record.parentId,scope)}}}__name(checkRestoredTree,"checkRestoredTree");export{checkRestoredTree};
+var __defProp=Object.defineProperty;var __name=(target,value)=>__defProp(target,"name",{value,configurable:!0});import{CallableRecord}from"../callable/record.js";import{CompositeRecord}from"../composite.js";import{InvocationRecord}from"../invocation/record.js";import{InvocationBoundaryRecord}from"../invocation/boundary/record.js";import{ResourceRecord}from"../resource/record.js";import{checkRelation}from"../tree/relation.js";function checkRestoredTree(book){const contexts=new Set,boundaries=new Map,resources=new Map;for(const record of book.values()){const parent=record.parentId===void 0?void 0:book.get(record.parentId);if(record.parentId!==void 0&&!(parent instanceof CompositeRecord))throw new Error("Stored record parent is missing or cannot contain children");if(parent instanceof CompositeRecord&&!parent.childIds.includes(record.id))throw new Error("Stored record parent does not reference its child");if(record instanceof CompositeRecord)for(const childId of record.childIds){const child=book.get(childId);if(!child||child.parentId!==record.id)throw new Error("Inconsistent stored child reference")}if(checkRelation(record,parent,book,"restore"),record instanceof InvocationRecord&&"contextId"in record){const contextId=record.contextId;if(contexts.has(contextId)||book.get(contextId))throw new Error("Stored invocation context identity conflicts");contexts.add(contextId);for(const relation of record.value.relationChanges){const child=relation.childId===void 0?void 0:book.get(relation.childId);if(child&&(child.parentId!==record.id||!("contextId"in child)||child.contextId!==relation.identity.childContextId))throw new Error("Stored child relation points to another invocation")}}if(record instanceof InvocationBoundaryRecord){const invocation=book.get(record.callId);if(invocation instanceof CallableRecord){let scope2=invocation;const parents=new Set([scope2.id]);let parent2=scope2.parentId?book.get(scope2.parentId):void 0;for(;parent2 instanceof CallableRecord;){if(parents.has(parent2.id))throw new Error("Stored callable ancestry contains a cycle");parents.add(parent2.id),scope2=parent2,parent2=scope2.parentId?book.get(scope2.parentId):void 0}if(record.scopeId!==scope2.id||record.executionId!==void 0)throw new Error("Stored callable boundary has an inconsistent timing scope")}else if(record.scopeId!==(record.executionId??record.callId))throw new Error("Stored boundary has an inconsistent timing scope");const scope=boundaries.get(record.scopeId)??{sequence:0,offsetMs:0,calls:new Map};if(record.sequence!==scope.sequence+1||record.offsetMs<scope.offsetMs)throw new Error("Stored boundary sequence does not advance");const prior=scope.calls.get(record.callId);if(record.value.type==="call"?prior!==void 0:prior!=="call")throw new Error("Stored boundary does not follow its call");const call=book.get(record.callId);if(record.value.type==="call"&&record.callId!==record.scopeId&&scope.calls.get(call.parentId)!=="call")throw new Error("Stored child boundary starts outside its parent work");if(record.value.type==="call"&&record.callId===record.scopeId&&record.sequence!==1)throw new Error("Stored work scope must start before its children");if(record.value.type!=="call"&&[...scope.calls].some(([id,state])=>state==="call"&&book.get(id)?.parentId===record.callId))throw new Error("Stored parent boundary ends before its active child");scope.sequence=record.sequence,scope.offsetMs=record.offsetMs,scope.calls.set(record.callId,record.value.type),boundaries.set(record.scopeId,scope)}if(record instanceof ResourceRecord){const scope=resources.get(record.parentId)??{sequence:0,accesses:new Map,interactions:new Map};if(!Number.isSafeInteger(record.sequence)||record.sequence<=scope.sequence)throw new Error("Stored resource sequence does not advance");const key=JSON.stringify([record.supplyId,record.access]);if(record.phase==="bound"){if(scope.accesses.has(key))throw new Error("Stored resource access is already bound");scope.accesses.set(key,record.phase)}else if(record.phase==="available"||record.phase==="unavailable"){if(scope.accesses.get(key)!=="bound")throw new Error("Stored resource access is not bound");scope.accesses.set(key,record.phase)}else if(record.phase==="started"){if(scope.accesses.get(key)!=="available"||scope.interactions.has(record.interactionId))throw new Error("Stored resource interaction is not available");scope.interactions.set(record.interactionId,key)}else{if(scope.interactions.get(record.interactionId)!==key)throw new Error("Stored resource interaction has not started");scope.interactions.delete(record.interactionId)}scope.sequence=record.sequence,resources.set(record.parentId,scope)}}}__name(checkRestoredTree,"checkRestoredTree");export{checkRestoredTree};

package/dist/root/record.d.ts

@@ -1,4 +1,4 @@
-import type { RecordingRootRecord as RecordingRootData, RecordingRootValue } from '@weiliang0121/capix-protocol';
+import type { RecordingRootRecord as RecordingRootData, RecordingRootValue } from '../data/index.js';
 import { CompositeRecord } from '../composite.js';
 export declare class RecordingRootRecord extends CompositeRecord<RecordingRootValue> implements RecordingRootData {
     readonly kind: "runtime";

package/dist/runtime/record.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeCallRecord as RuntimeCallData, RuntimeCallValue } from '@weiliang0121/capix-protocol';
+import type { RuntimeCallRecord as RuntimeCallData, RuntimeCallValue } from '../data/index.js';
 import { InvocationRecord } from '../invocation/record.js';
 export declare class RuntimeCallRecord extends InvocationRecord<RuntimeCallValue> implements RuntimeCallData {
     readonly contextId: string;

package/dist/transcript/helper.d.ts

@@ -1,4 +1,4 @@
-import type { TranscriptChange } from '@weiliang0121/capix-protocol';
+import type { TranscriptChange } from '../data/index.js';
 import type { RecordClock } from '../recorder.js';
 import { TranscriptRecord, type TranscriptRecordOptions } from './record.js';
 export declare class TranscriptRecordHelper {

package/dist/transcript/record.d.ts

@@ -1,4 +1,4 @@
-import type { TranscriptChange, TranscriptRecord as RecordData } from '@weiliang0121/capix-protocol';
+import type { TranscriptChange, TranscriptRecord as RecordData } from '../data/index.js';
 import type { RecordChangeSource } from '../source.js';
 import { BaseRecord } from '../record.js';
 export interface TranscriptRecordOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weiliang0121/capix-records",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -11,14 +11,19 @@
     "./construction": {
       "types": "./dist/construction.d.ts",
       "import": "./dist/construction.js"
+    },
+    "./data": {
+      "types": "./dist/data/index.d.ts",
+      "import": "./dist/data/index.js"
     }
   },
   "dependencies": {
     "es-toolkit": "1.52.0",
-    "@weiliang0121/capix-contracts": "0.1.0",
-    "@weiliang0121/capix-resources": "0.1.0",
-    "@weiliang0121/capix-protocol": "0.1.0",
-    "@weiliang0121/capix-changes": "0.1.0"
+    "@weiliang0121/capix-contracts": "0.2.0",
+    "@weiliang0121/capix-changes": "0.2.0",
+    "@weiliang0121/capix-memory": "0.2.0",
+    "@weiliang0121/capix-resources": "0.2.0",
+    "@weiliang0121/capix-transcript": "0.2.0"
   },
   "description": "Optional recording entities and resource contracts for CAPiX.",
   "license": "MIT",
@@ -26,7 +31,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/weiliang0121/capix.git",
-    "directory": "server/records"
+    "directory": "packages/records"
   },
   "engines": {
     "node": ">=22.23.2"
@@ -45,6 +50,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node ../../scripts/test/run.mjs --package ."
   }
 }