@weiliang0121/capix-structure 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wei.liang (https://github.com/weiliang0121)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @weiliang0121/capix-structure
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Composable Scene, Group, and Node structures for CAPiX.
+
+ES modules and TypeScript declarations. Requires Node.js 22.23.2 or newer.
+
+```sh
+npm install @weiliang0121/capix-structure
+```
+
+## Public entry points
+
+- `@weiliang0121/capix-structure`
+- `@weiliang0121/capix-structure/construction`
+
+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).

package/dist/callable.d.ts

@@ -0,0 +1,18 @@
+import type { CallableKind, invocationSignature, InvocationSignature } from '@weiliang0121/capix-contracts';
+import type { CallableDescription, CallableDefinition, CallableRun, EmptyResources } from './definition/callable.js';
+import type { ChildContractsOf } from './definition/children.js';
+import type { ResourceRequirements } from '@weiliang0121/capix-resources';
+export type CallableStructure<Kind extends CallableKind> = Callable<any, any, Kind, any, any>;
+export declare abstract class Callable<Input, Output, Kind extends CallableKind, Resources extends object = EmptyResources, Delta = never> {
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly kind: Kind;
+    readonly [invocationSignature]: InvocationSignature<Input, Output, Delta>;
+    name?: string;
+    label?: string;
+    source?: string;
+    deps?: ResourceRequirements<Resources>;
+    run?: CallableRun<Input, Output, Kind, Resources, ChildContractsOf<Kind>, Delta, this>;
+    output?: CallableDescription<Input, Output, Kind, Delta>['output'];
+    checkpoint?: CallableDescription<Input, Output, Kind, Delta>['checkpoint'];
+    protected constructor(kind: Kind, configuration?: CallableDefinition<Input, Output, Kind, Resources, Delta>);
+}

package/dist/callable.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{randomUUID}from"node:crypto";import{initializeStructureConfiguration}from"./configuration.js";class Callable{static{__name(this,"Callable")}id=randomUUID();kind;name;label;source;deps;run;output;checkpoint;constructor(kind,configuration){if(initializeStructureConfiguration(this),configuration!==void 0&&(!configuration||typeof configuration!="object"))throw new TypeError("Callable configuration must be an object");for(const field of["kind","members","setRun","setDefinition","accept","exceptions","raises","maxRounds","uses","observation","callee","receptions"])if(configuration&&field in configuration)throw new TypeError(`Unsupported callable configuration field: ${field}`);this.kind=kind,this.name=configuration?.name,this.label=configuration?.label,this.source=configuration?.source,this.deps=configuration?.deps,this.run=configuration?.run?.bind(configuration),this.output=configuration?.output,this.checkpoint=configuration?.checkpoint,Object.defineProperty(this,"id",{value:this.id,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"kind",{value:kind,enumerable:!0,writable:!1,configurable:!1})}}export{Callable};

package/dist/composition/dynamic.d.ts

@@ -0,0 +1,32 @@
+import { Group } from '../group.js';
+import type { MemberInput } from './input.js';
+import type { ChildCallable } from '../definition/children.js';
+import type { CallableInput, CallableOutput, Stable } from '@weiliang0121/capix-contracts';
+import type { MemberRegistration, NamedMembers } from '../definition/composition.js';
+export type DynamicCall<Options extends NamedMembers> = {
+    [Name in keyof Options & string]: {
+        readonly kind: 'call';
+        readonly option: Name;
+        readonly input: MemberInput<Options[Name]> | Stable<MemberInput<Options[Name]>>;
+    };
+}[keyof Options & string];
+export type DynamicFinish<Output> = {
+    readonly kind: 'finish';
+    readonly value: Output;
+};
+export type DynamicDecision<Options extends NamedMembers, Output> = DynamicCall<Options> | DynamicFinish<Output>;
+type FinishValue<Value> = Value extends DynamicFinish<infer Output> ? Output : never;
+export type DynamicOutput<Decision extends ChildCallable> = FinishValue<CallableOutput<Decision>>;
+type DecisionCheck<Options extends NamedMembers, Decision extends ChildCallable> = [CallableOutput<Decision>] extends [DynamicDecision<Options, unknown>] ? ([CallableInput<Decision>] extends [MemberInput<Decision>] ? unknown : never) : never;
+export interface DynamicConfiguration<Options extends NamedMembers, Decision extends ChildCallable> {
+    readonly options: MemberRegistration<Options>;
+    readonly decide: Decision & NoInfer<DecisionCheck<Options, Decision>>;
+    readonly maxSteps?: number;
+}
+export declare class Dynamic<const Options extends NamedMembers, Decision extends ChildCallable> extends Group<MemberInput<Decision>, DynamicOutput<Decision>> {
+    #private;
+    readonly run: NonNullable<Group<MemberInput<Decision>, DynamicOutput<Decision>>['run']>;
+    constructor(configuration: DynamicConfiguration<Options, Decision>);
+    get maxSteps(): number;
+}
+export {};

package/dist/composition/dynamic.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{types}from"node:util";import{Group}from"../group.js";import{checkMemberName}from"../members.js";class Dynamic extends Group{static{__name(this,"Dynamic")}#maxSteps;constructor(configuration){if(super(),!configuration||typeof configuration!="object"||types.isProxy(configuration))throw new TypeError("Dynamic configuration must be an object");const options=snapshotOptions(configuration.options),decision=configuration.decide,maxSteps=checkMaxSteps(configuration.maxSteps??8);this.add(...options.values(),decision),this.#maxSteps=maxSteps;const run=__name(async work=>{for(let step=0;step<=maxSteps;step++){const next=await work.children.invoke(decision,work.input,{key:`decision:${step}`}),selected=checkDecision(next,options);if(selected.kind==="finish")return selected.value;step<maxSteps&&await work.children.invoke(selected.node,selected.input,{key:`option:${step}:${selected.option}`})}throw new Error(`Dynamic exceeded ${maxSteps} action steps`)},"run");Object.defineProperty(this,"run",{get:__name(()=>run,"get"),enumerable:!0,configurable:!0})}get maxSteps(){return this.#maxSteps}}function checkMaxSteps(value){if(!Number.isSafeInteger(value)||value<0)throw new RangeError("Dynamic maxSteps must be a non-negative safe integer");return value}__name(checkMaxSteps,"checkMaxSteps");function snapshotOptions(options){if(!options||typeof options!="object"||Array.isArray(options)||types.isProxy(options))throw new TypeError("Dynamic options must be an object");if(Object.getOwnPropertySymbols(options).length)throw new TypeError("Dynamic option names must be strings");const entries=[];for(const[name,descriptor]of Object.entries(Object.getOwnPropertyDescriptors(options))){if(checkMemberName(name),!("value"in descriptor))throw new TypeError("Dynamic options must use data properties");entries.push([name,descriptor.value])}return new Map(entries)}__name(snapshotOptions,"snapshotOptions");function checkDecision(value,options){if(!value||typeof value!="object"||Array.isArray(value))throw new TypeError("Dynamic decision must be a call or finish object");const decision=value;if(decision.kind==="finish"&&Object.hasOwn(decision,"value"))return{kind:"finish",value:decision.value};if(decision.kind!=="call"||typeof decision.option!="string"||!Object.hasOwn(decision,"input"))throw new TypeError("Dynamic decision must be a call or finish object");const node=options.get(decision.option);if(!node)throw new Error(`Dynamic option is not registered: ${decision.option}`);return{kind:"call",option:decision.option,node,input:decision.input}}__name(checkDecision,"checkDecision");export{Dynamic};

package/dist/composition/input.d.ts

@@ -0,0 +1,2 @@
+import type { CallableInput, ChildContract } from '@weiliang0121/capix-contracts';
+export type MemberInput<Member extends ChildContract> = (Member extends unknown ? (input: CallableInput<Member>) => void : never) extends (input: infer Input) => void ? Input : never;

package/dist/composition/input.js

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

package/dist/composition/sequence.d.ts

@@ -0,0 +1,58 @@
+import { Group } from '../group.js';
+import type { ChildCallable } from '../definition/children.js';
+import type { MemberInput } from './input.js';
+import type { Stable, CallableDelta, CallableOutput, InvocationOutputWriter, OperationResult, OutputDeclaration } from '@weiliang0121/capix-contracts';
+export type SequenceScope<Input, Previous, Delta = never> = {
+    readonly input: Stable<Input>;
+    readonly previous: Stable<Previous>;
+} & ([Delta] extends [never] ? object : {
+    readonly output: InvocationOutputWriter<Delta>;
+});
+export interface SequenceStep<Member extends ChildCallable, Input = MemberInput<Member>, Previous = Input, Delta = never> {
+    readonly node: Member;
+    readonly key?: string;
+    readonly input?: (scope: SequenceScope<Input, Previous, Delta>) => MemberInput<Member> | Stable<MemberInput<Member>>;
+    readonly delta?: [CallableDelta<Member>] extends [never] ? never : (delta: Stable<CallableDelta<Member>>, scope: SequenceScope<Input, Previous, Delta>) => void;
+    readonly result?: {
+        readonly succeeded?: (value: Stable<CallableOutput<Member>>, scope: SequenceScope<Input, Previous, Delta>) => unknown;
+        readonly failed?: (failure: unknown, scope: SequenceScope<Input, Previous, Delta>) => unknown;
+    };
+}
+export type SequenceItem = ChildCallable | {
+    readonly node: ChildCallable;
+};
+type StepNode<Step> = Step extends ChildCallable ? Step : Step extends {
+    readonly node: infer Member extends ChildCallable;
+} ? Member : never;
+type Accepted<Step> = Stable<OperationResult<Stable<CallableOutput<StepNode<Step>>>, Step>>;
+type Initial<Step> = Step extends {
+    readonly input: (scope: infer Scope) => unknown;
+} ? (Scope extends {
+    readonly input: infer Input;
+} ? Input : unknown) : MemberInput<StepNode<Step>>;
+export type SequenceInput<Steps extends readonly SequenceItem[]> = Steps extends readonly [infer First, ...unknown[]] ? Initial<First> : unknown;
+export type SequenceOutput<Steps extends readonly SequenceItem[]> = Steps extends readonly [...unknown[], infer Last] ? Accepted<Last> : SequenceInput<Steps>;
+type ValidStep<Step, Input, Previous, Delta> = Step extends ChildCallable ? ([Previous] extends [MemberInput<Step> | Stable<MemberInput<Step>>] ? true : false) : Step extends SequenceStep<StepNode<Step>, Input, Previous, Delta> ? (Step extends {
+    readonly input: (scope: never) => unknown;
+} ? true : [Previous] extends [MemberInput<StepNode<Step>> | Stable<MemberInput<StepNode<Step>>>] ? true : false) : false;
+type ValidSteps<Steps extends readonly SequenceItem[], Input, Previous, Delta> = Steps extends readonly [infer First extends SequenceItem, ...infer Rest extends readonly SequenceItem[]] ? ([ValidStep<First, Input, Previous, Delta>] extends [true] ? ValidSteps<Rest, Input, Accepted<First>, Delta> : false) : Steps extends readonly [] ? true : false;
+type CheckedSteps<Steps extends readonly SequenceItem[], Delta> = [SequenceInput<Steps>] extends [never] ? never : ValidSteps<Steps, SequenceInput<Steps>, SequenceInput<Steps>, Delta> extends true ? unknown : never;
+type SequenceOptions<Output, Delta> = {
+    readonly output?: OutputDeclaration<Output, Delta>;
+} & ([Delta] extends [never] ? object : {
+    readonly output: OutputDeclaration<Output, Delta> & {
+        readonly delta: (value: unknown) => Delta;
+    };
+});
+type SequenceConfiguration<Output, Delta> = [options: SequenceOptions<Output, Delta>] | ([Delta] extends [never] ? [] : never);
+export declare class Sequence<const Steps extends readonly SequenceItem[], Delta = never> extends Group<SequenceInput<Steps>, SequenceOutput<Steps>, {}, Delta> {
+    #private;
+    readonly run: NonNullable<Group<SequenceInput<Steps>, SequenceOutput<Steps>, {}, Delta>['run']>;
+    readonly output: OutputDeclaration<SequenceOutput<Steps>, Delta> | undefined;
+    constructor(steps: Steps & CheckedSteps<NoInfer<Steps>, NoInfer<Delta>>, ...configuration: SequenceConfiguration<NoInfer<SequenceOutput<Steps>>, Delta>);
+    get steps(): readonly {
+        readonly key: string;
+        readonly node: ChildCallable;
+    }[];
+}
+export {};

package/dist/composition/sequence.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{types}from"node:util";import{Callable}from"../callable.js";import{Group}from"../group.js";import{requireChildCallable}from"../members.js";class Sequence extends Group{static{__name(this,"Sequence")}#steps;constructor(steps,...configuration){if(super(),!Array.isArray(steps)||types.isProxy(steps))throw new TypeError("Sequence steps must be an array");const entries=[];for(let index=0;index<steps.length;index++){const item=Object.getOwnPropertyDescriptor(steps,String(index));if(!item||!("value"in item))throw new TypeError("Sequence steps must be present data entries");entries.push(prepareStep(item.value,index))}this.#steps=Object.freeze(entries);const outputDeclaration=snapshotOutput(configuration[0]),run=__name(async work=>{let previous=work.input;const output="output"in work?work.output:void 0;for(const step of this.#steps)previous=await step.invoke(work.input,previous,work.children,output);return previous},"run");Object.defineProperty(this,"run",{get:__name(()=>run,"get"),enumerable:!0,configurable:!0}),Object.defineProperty(this,"output",{get:__name(()=>outputDeclaration,"get"),enumerable:!0,configurable:!0}),this.add(...entries.map(entry=>entry.node))}get steps(){return Object.freeze(this.#steps.map(({key,node})=>Object.freeze({key,node})))}}function requireConfiguration(value){if(!value||typeof value!="object"||Array.isArray(value)||types.isProxy(value))throw new TypeError("Sequence configuration must be a data object")}__name(requireConfiguration,"requireConfiguration");function readField(configuration,name){const field=Object.getOwnPropertyDescriptor(configuration,name);if(!field&&name in configuration)throw new TypeError("Sequence configuration must use own data properties");if(field&&!("value"in field))throw new TypeError("Sequence configuration must use data properties");return field?.value}__name(readField,"readField");function snapshotOutput(options){if(options===void 0)return;requireConfiguration(options);const output=readField(options,"output");if(output===void 0)return;requireConfiguration(output);const result=readField(output,"result"),delta=readField(output,"delta");if(typeof result!="function"||delta!==void 0&&typeof delta!="function")throw new TypeError("Sequence output needs result and optional delta functions");return Object.freeze({result:result.bind(output),...delta?{delta:delta.bind(output)}:{}})}__name(snapshotOutput,"snapshotOutput");function prepareStep(value,index){if(types.isProxy(value))throw new TypeError("Sequence steps cannot be proxies");const direct=value instanceof Callable;direct||requireConfiguration(value);const configuration=direct?void 0:value,node=direct?value:readField(configuration,"node");requireChildCallable(node);const key=(configuration?readField(configuration,"key"):void 0)??`step:${index}`;if(typeof key!="string"||!key.trim())throw new TypeError("Sequence step key must be non-blank");const prepare=configuration?readField(configuration,"input"):void 0,delta=configuration?readField(configuration,"delta"):void 0,result=configuration?readField(configuration,"result"):void 0;result!==void 0&&requireConfiguration(result);const succeeded=result?readField(result,"succeeded"):void 0,failed=result?readField(result,"failed"):void 0;for(const callback of[prepare,delta,succeeded,failed])if(callback!==void 0&&typeof callback!="function")throw new TypeError("Sequence step callbacks must be functions");const inputFor=typeof prepare=="function"?prepare.bind(configuration):void 0,emit=typeof delta=="function"?delta.bind(configuration):void 0,receive=typeof succeeded=="function"?succeeded.bind(result):void 0,handle=typeof failed=="function"?failed.bind(result):void 0;return Object.freeze({key,node,async invoke(input,previous,children,output){const scope=Object.freeze({input,previous,...output?{output}:{}}),childInput=inputFor?inputFor(scope):previous;return children.invoke(node,childInput,{key,...emit?{delta:__name(value2=>emit(value2,scope),"delta")}:{},result:{...receive?{succeeded:__name(value2=>receive(value2,scope),"succeeded")}:{},...handle?{failed:__name(failure=>handle(failure,scope),"failed")}:{}}})}})}__name(prepareStep,"prepareStep");export{Sequence};

package/dist/configuration.d.ts

@@ -0,0 +1,7 @@
+export declare function initializeStructureConfiguration(structure: object): void;
+export declare function assertStructureConfigurable(structure: object): void;
+export declare function structureParent(structure: object): object | undefined;
+export declare function claimStructureMembers(owner: object, members: readonly object[]): void;
+export declare function beginStructureBuild(structure: object): void;
+export declare function endStructureBuild(structure: object): void;
+export declare function lockStructureConfiguration(structure: object): void;

package/dist/configuration.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{types}from"node:util";const configuration=Symbol("callable-configuration");function initializeStructureConfiguration(structure){Object.defineProperty(structure,configuration,{value:{phase:"configuring"}})}__name(initializeStructureConfiguration,"initializeStructureConfiguration");function state(structure){if(types.isProxy(structure))throw new TypeError("Callable structures cannot be proxies");if(!Object.hasOwn(structure,configuration))throw new TypeError("Callable configuration is not initialized");return structure[configuration]}__name(state,"state");function assertStructureConfigurable(structure){const phase=state(structure).phase;if(phase!=="configuring")throw new Error(phase==="building"?"Callable structure configuration is locked while building":"Callable structure configuration is locked after build")}__name(assertStructureConfigurable,"assertStructureConfigurable");function structureParent(structure){return state(structure).parent}__name(structureParent,"structureParent");function claimStructureMembers(owner,members){for(const member of members){const current=state(member);if(assertStructureConfigurable(member),current.parent&&current.parent!==owner)throw new Error("Callable member already belongs to another parent")}for(const member of members)state(member).parent=owner}__name(claimStructureMembers,"claimStructureMembers");function beginStructureBuild(structure){assertStructureConfigurable(structure),state(structure).phase="building"}__name(beginStructureBuild,"beginStructureBuild");function endStructureBuild(structure){const current=state(structure);current.phase==="building"&&(current.phase="configuring")}__name(endStructureBuild,"endStructureBuild");function lockStructureConfiguration(structure){state(structure).phase="built"}__name(lockStructureConfiguration,"lockStructureConfiguration");export{assertStructureConfigurable,beginStructureBuild,claimStructureMembers,endStructureBuild,initializeStructureConfiguration,lockStructureConfiguration,structureParent};

package/dist/construction.d.ts

@@ -0,0 +1,4 @@
+export { assertStructureConfigurable, beginStructureBuild, endStructureBuild, lockStructureConfiguration, structureParent } from './configuration.js';
+export { checkMemberName } from './members.js';
+export { childKinds } from './definition/kind.js';
+export { callableDependencies, type CallableDependencies } from './definition/dependencies.js';

package/dist/construction.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+import{assertStructureConfigurable,beginStructureBuild,endStructureBuild,lockStructureConfiguration,structureParent}from"./configuration.js";import{checkMemberName}from"./members.js";import{childKinds}from"./definition/kind.js";import{callableDependencies}from"./definition/dependencies.js";export{assertStructureConfigurable,beginStructureBuild,callableDependencies,checkMemberName,childKinds,endStructureBuild,lockStructureConfiguration,structureParent};

package/dist/definition/callable.d.ts

@@ -0,0 +1,29 @@
+import type { CallableKind, OutputDeclaration, Stable } from '@weiliang0121/capix-contracts';
+import type { ResourceRequirements } from '@weiliang0121/capix-resources';
+import type { ChildContractsOf } from './children.js';
+import type { InvocationCheckpointDefinition } from './checkpoint.js';
+import type { CallableWork } from './work.js';
+import type { NamedWork } from './composition.js';
+export type { InvocationCheckpointPoint, InvocationCheckpointDefinition } from './checkpoint.js';
+export type EmptyResources = Readonly<Record<never, never>>;
+export type CallableRun<Input, Output, Kind extends CallableKind, Resources extends object, Allowed extends ChildContractsOf<Kind> = ChildContractsOf<Kind>, Delta = never, Owner = unknown> = (work: NamedWork<CallableWork<Kind, Input, Output, Resources, Allowed, Delta>, Owner, Allowed>) => Output | Stable<Output> | Promise<Output | Stable<Output>>;
+export interface CallableDescription<Input, Output, Kind extends CallableKind, Delta = never> {
+    readonly kind?: never;
+    readonly members?: never;
+    readonly name?: string;
+    readonly label?: string;
+    readonly source?: string;
+    readonly output?: OutputDeclaration<Output, Delta>;
+    readonly checkpoint?: InvocationCheckpointDefinition<Input, Output, Kind, Delta>;
+}
+type RequiredDependencies<Resources extends object> = [keyof Resources] extends [never] ? {
+    readonly deps?: ResourceRequirements<Resources>;
+} : {
+    readonly deps: ResourceRequirements<Resources>;
+};
+export type CallableDefinition<Input, Output, Kind extends CallableKind, Resources extends object = EmptyResources, Delta = never> = CallableDescription<Input, Output, Kind, Delta> & ({
+    readonly deps?: ResourceRequirements<Resources>;
+    readonly run?: undefined;
+} | (RequiredDependencies<Resources> & {
+    readonly run: CallableRun<Input, Output, Kind, Resources, ChildContractsOf<Kind>, Delta>;
+}));

package/dist/definition/callable.js

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

package/dist/definition/checkpoint.d.ts

@@ -0,0 +1,38 @@
+import type { ResourceRequirements, ResourceRequests, ResourcesOf } from '@weiliang0121/capix-resources';
+import type { Stable, CallableKind, CheckpointCodec, CheckpointContract, ChildContract, ChildReferenceSlot, SavedReferences, CheckpointFacts, CheckpointPointOwner } from '@weiliang0121/capix-contracts';
+import type { ChildContractsOf } from './children.js';
+import type { ResumeWork } from './work.js';
+import type { DefinitionReceptions } from './reception.js';
+type CheckpointReferenceSlotsFor<Kind extends CallableKind> = Kind extends 'node' ? Readonly<Record<string, never>> : Readonly<Record<string, ChildReferenceSlot<ChildContractsOf<Kind>>>>;
+export declare function childReference<Definition extends ChildContract>(definition: Definition): ChildReferenceSlot<Definition, false>;
+export declare function childReferences<Definition extends ChildContract>(definition: Definition): ChildReferenceSlot<Definition, true>;
+export interface InvocationCheckpointPoint<Input, Output, Kind extends CallableKind, State, Resources extends object = Record<string, never>, Slots extends CheckpointReferenceSlotsFor<Kind> = CheckpointReferenceSlotsFor<Kind>, Allowed extends ChildContractsOf<Kind> = never, Delta = never> extends CheckpointPointOwner<Kind, Input, Output, Delta> {
+    readonly name: string;
+    readonly state: CheckpointCodec<State>;
+    readonly references: Slots;
+    check?(state: Stable<State>, facts: CheckpointFacts<Input, Slots>): void;
+    readonly resume: {
+        readonly deps: ResourceRequirements<Resources>;
+        readonly uses?: readonly Allowed[];
+        run(work: ResumeWork<Kind, Input, Output, Resources, Allowed, Delta>, state: Stable<State>, saved: SavedReferences<Slots>): Output | Stable<Output> | Promise<Output | Stable<Output>>;
+    };
+}
+export interface InvocationCheckpointDefinition<Input, Output, Kind extends CallableKind, Delta = never> extends CheckpointContract {
+    readonly input: CheckpointCodec<Input>;
+    readonly output: CheckpointCodec<Output>;
+    readonly points: readonly InvocationCheckpointPoint<Input, Output, Kind, any, any, any, any, Delta>[];
+    readonly receptions?: DefinitionReceptions<Kind>;
+}
+interface PointOptions<Kind extends CallableKind, Input, Output, State, Slots extends CheckpointReferenceSlotsFor<Kind>, Deps extends ResourceRequests, Uses extends readonly ChildContractsOf<Kind>[], Delta> {
+    readonly name: string;
+    readonly state: CheckpointCodec<State>;
+    readonly references: Slots;
+    readonly check?: (state: NoInfer<Stable<State>>, facts: CheckpointFacts<Input, NoInfer<Slots>>) => void;
+    readonly resume: {
+        readonly deps?: Deps;
+        readonly uses?: Uses;
+        readonly run: (work: ResumeWork<Kind, Input, Output, ResourcesOf<NoInfer<Deps>>, Uses[number], Delta>, state: NoInfer<Stable<State>>, saved: SavedReferences<NoInfer<Slots>>) => Output | Stable<Output> | Promise<Output | Stable<Output>>;
+    };
+}
+export declare function checkpointPoint<Kind extends CallableKind, Input, Output, Delta = never>(): <State, const Slots extends CheckpointReferenceSlotsFor<Kind>, const Deps extends ResourceRequests = Readonly<Record<never, never>>, const Uses extends readonly ChildContractsOf<Kind>[] = readonly []>(options: PointOptions<Kind, Input, Output, State, Slots, Deps, Uses, Delta>) => InvocationCheckpointPoint<Input, Output, Kind, State, ResourcesOf<Deps>, Slots, Uses[number], Delta>;
+export {};

package/dist/definition/checkpoint.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 childReference(definition){return Object.freeze({definition,many:!1})}__name(childReference,"childReference");function childReferences(definition){return Object.freeze({definition,many:!0})}__name(childReferences,"childReferences");function checkpointPoint(){return options=>{const deps=options.resume.deps??{};return Object.freeze({name:options.name,state:options.state,references:options.references,check:options.check?.bind(options),resume:{deps,uses:options.resume.uses,run:options.resume.run.bind(options.resume)}})}}__name(checkpointPoint,"checkpointPoint");export{checkpointPoint,childReference,childReferences};

package/dist/definition/children.d.ts

@@ -0,0 +1,9 @@
+import type { CallableKind, ChildContract } from '@weiliang0121/capix-contracts';
+import type { CallableStructure } from '../callable.js';
+import type { Composite } from './composition.js';
+import type { ChildKind } from './kind.js';
+export type ChildCallable = (CallableStructure<'group'> & Composite) | (CallableStructure<'node'> & {
+    readonly members?: never;
+});
+export type ChildrenOf<Kind extends CallableKind> = [ChildKind<Kind>] extends [never] ? never : ChildCallable;
+export type ChildContractsOf<Kind extends CallableKind> = [ChildKind<Kind>] extends [never] ? never : ChildContract;

package/dist/definition/children.js

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

package/dist/definition/composition.d.ts

@@ -0,0 +1,30 @@
+import type { ChildCallable } from './children.js';
+import type { Stable, ChildContract, ChildOperationOptions, ChildReceptionOptions, CallableInput, CallableOutput, ReceptionDefinition, OperationResult } from '@weiliang0121/capix-contracts';
+export type NamedMembers = Readonly<Record<string, ChildCallable>>;
+type ReservedMemberName = '' | 'invoke' | 'create' | 'open' | 'facts' | 'resume' | '__proto__' | 'prototype' | 'constructor' | 'toString' | 'toLocaleString' | 'valueOf' | 'hasOwnProperty' | 'isPrototypeOf' | 'propertyIsEnumerable' | '__defineGetter__' | '__defineSetter__' | '__lookupGetter__' | '__lookupSetter__';
+export type MemberRegistration<Names extends NamedMembers> = Names & {
+    readonly [Name in keyof Names]: Name extends string ? (Name extends ReservedMemberName ? never : Names[Name]) : never;
+};
+declare const memberNames: unique symbol;
+export interface NamedMemberRegistration<Names extends NamedMembers> {
+    readonly [memberNames]: Names;
+}
+type MemberNamesOf<Owner> = Owner extends NamedMemberRegistration<infer Names> ? Names : {};
+interface NamedChildOperation<Definition extends ChildContract> {
+    invoke(input: CallableInput<Definition> | Stable<CallableInput<Definition>>): Promise<Stable<CallableOutput<Definition>>>;
+    invoke<Value, const Options extends NoInfer<ChildReceptionOptions<Definition, Value>>>(input: CallableInput<Definition> | Stable<CallableInput<Definition>>, options: Options & {
+        readonly reception: ReceptionDefinition<Definition, Value>;
+    }): Promise<Stable<OperationResult<Stable<CallableOutput<Definition>>, Options>>>;
+    invoke<const Options extends ChildOperationOptions<Definition>>(input: CallableInput<Definition> | Stable<CallableInput<Definition>>, options: Options & ChildOperationOptions<Definition>): Promise<Stable<OperationResult<Stable<CallableOutput<Definition>>, Options>>>;
+}
+type NamedChildOperations<Owner, Allowed extends ChildContract> = {
+    readonly [Name in keyof MemberNamesOf<Owner> as MemberNamesOf<Owner>[Name] extends Allowed ? Name : never]: MemberNamesOf<Owner>[Name] extends ChildContract ? NamedChildOperation<MemberNamesOf<Owner>[Name]> : never;
+};
+export type NamedWork<Work, Owner, Allowed extends ChildContract> = keyof NamedChildOperations<Owner, Allowed> extends never ? Work : Work & {
+    readonly children: NamedChildOperations<Owner, Allowed>;
+};
+export interface Composite<Members extends readonly ChildCallable[] = readonly ChildCallable[]> {
+    readonly members: Members;
+    readonly names?: NamedMembers;
+}
+export {};

package/dist/definition/composition.js

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

package/dist/definition/dependencies.d.ts

@@ -0,0 +1,13 @@
+import type { ResourceRequirements } from '@weiliang0121/capix-resources';
+export interface CallableDependencies {
+    readonly deps?: ResourceRequirements;
+    readonly checkpoint?: {
+        readonly points: readonly {
+            readonly name: string;
+            readonly resume: {
+                readonly deps: ResourceRequirements;
+            };
+        }[];
+    };
+}
+export declare function callableDependencies(definition: CallableDependencies): ResourceRequirements;

package/dist/definition/dependencies.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 callableDependencies(definition){const deps={};for(const[name,request]of Object.entries(definition.deps??{}))deps[`run.${name}`]=request;for(const point of definition.checkpoint?.points??[])for(const[name,request]of Object.entries(point.resume.deps))deps[`checkpoint.${point.name}.${name}`]=request;return Object.freeze(deps)}__name(callableDependencies,"callableDependencies");export{callableDependencies};

package/dist/definition/factory.d.ts

@@ -0,0 +1,49 @@
+import type { CallableKind } from '@weiliang0121/capix-contracts';
+import type { OutputDeclaration } from '@weiliang0121/capix-contracts';
+import type { ChildrenOf } from './children.js';
+import type { InvocationCheckpointDefinition } from './checkpoint.js';
+import { type ResourceRequests, type ResourcesOf } from '@weiliang0121/capix-resources';
+import type { CallableWork } from './work.js';
+import { Scene } from '../scene.js';
+import { Group } from '../group.js';
+import { Node } from '../node.js';
+import type { ReceptionRegistration } from '@weiliang0121/capix-contracts';
+type EmptyDependencies = Readonly<Record<never, never>>;
+type LocalDependencies<Common extends ResourceRequests, Deps extends ResourceRequests> = Deps & {
+    readonly [Name in keyof Common]?: never;
+};
+type FactoryMembers<Kind extends CallableKind, Children extends readonly ChildrenOf<Kind>[]> = Kind extends 'node' ? {
+    readonly members?: never;
+} : {
+    readonly members?: Children;
+};
+interface DefinitionOptions<Kind extends CallableKind, Input, Output, Children extends readonly ChildrenOf<Kind>[], Deps extends ResourceRequests, Delta, Common extends ResourceRequests = EmptyDependencies> {
+    readonly name?: string;
+    readonly label?: string;
+    readonly source?: string;
+    readonly checkpoint?: Omit<InvocationCheckpointDefinition<Input, Output, Kind, NoInfer<Delta>>, 'receptions'> & {
+        readonly receptions?: Kind extends 'node' ? never : readonly ReceptionRegistration<NoInfer<Children[number]>>[];
+    };
+    readonly deps?: LocalDependencies<Common, Deps>;
+    readonly run: (work: CallableWork<Kind, Input, Output, ResourcesOf<NoInfer<Common & Deps>>, Children[number], Delta>) => Output | Promise<Output>;
+}
+type FactoryDefinition<Kind extends CallableKind, Input, Output, Resources extends object, Delta> = Kind extends 'scene' ? Scene<Input, Output, Resources, Delta> : Kind extends 'group' ? Group<Input, Output, Resources, Delta> : Node<Input, Output, Resources, Delta>;
+interface DefinitionFactory<Kind extends CallableKind, Input, Output, Common extends ResourceRequests = EmptyDependencies> {
+    <Delta, const Children extends readonly ChildrenOf<Kind>[] = readonly [], const Deps extends ResourceRequests = Readonly<Record<never, never>>>(options: DefinitionOptions<Kind, Input, Output, Children, Deps, NoInfer<Delta>, Common> & FactoryMembers<Kind, Children> & {
+        readonly output: OutputDeclaration<Output, Delta> & {
+            readonly delta: (value: unknown) => Delta;
+        };
+    }): FactoryDefinition<Kind, Input, Output, ResourcesOf<NoInfer<Common & Deps>>, Delta>;
+    <const Children extends readonly ChildrenOf<Kind>[] = readonly [], const Deps extends ResourceRequests = Readonly<Record<never, never>>>(options: DefinitionOptions<Kind, Input, Output, Children, Deps, never, Common> & FactoryMembers<Kind, Children> & {
+        readonly output?: OutputDeclaration<Output, never>;
+    }): FactoryDefinition<Kind, Input, Output, ResourcesOf<NoInfer<Common & Deps>>, never>;
+}
+export declare function defineScene<Input, Output>(): DefinitionFactory<'scene', Input, Output>;
+export declare function defineGroup<Input, Output>(): DefinitionFactory<'group', Input, Output>;
+export declare function defineNode<Input, Output>(): DefinitionFactory<'node', Input, Output>;
+export declare function withDependencies<const Common extends ResourceRequests>(dependencies: Common): Readonly<{
+    node<Input, Output>(): DefinitionFactory<"node", Input, Output, Common>;
+    group<Input, Output>(): DefinitionFactory<"group", Input, Output, Common>;
+    scene<Input, Output>(): DefinitionFactory<"scene", Input, Output, Common>;
+}>;
+export {};

package/dist/definition/factory.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{ResourceRequest}from"@weiliang0121/capix-resources";import{Scene}from"../scene.js";import{Group}from"../group.js";import{Node}from"../node.js";function factory(kind,common){return __name(options=>{if(kind==="node"&&options.members!==void 0)throw new TypeError("Node cannot have members");const members=options.members;for(const field of["setRun","setDefinition","accept","exceptions","raises","maxRounds","uses","observation","callee","receptions"])if(field in options)throw new TypeError(`Unsupported callable configuration field: ${field}`);for(const name of Object.keys(common??{}))if(Object.hasOwn(options.deps??{},name))throw new Error(`Duplicate common dependency alias: ${name}`);const deps=common?Object.freeze({...common,...options.deps}):options.deps,definition={...{name:options.name,label:options.label,source:options.source,deps,run:options.run,output:options.output,checkpoint:options.checkpoint},run:options.run.bind(options)},structure=kind==="scene"?new Scene(definition):kind==="group"?new Group(definition):new Node(definition);return"add"in structure&&structure.add(...members??[]),structure},"create")}__name(factory,"factory");function defineScene(){return factory("scene")}__name(defineScene,"defineScene");function defineGroup(){return factory("group")}__name(defineGroup,"defineGroup");function defineNode(){return factory("node")}__name(defineNode,"defineNode");function withDependencies(dependencies){const common=Object.freeze({...dependencies});for(const request of Object.values(common))if(!(request instanceof ResourceRequest))throw new TypeError("Common dependencies must be resource requests");return Object.freeze({node(){return factory("node",common)},group(){return factory("group",common)},scene(){return factory("scene",common)}})}__name(withDependencies,"withDependencies");export{defineGroup,defineNode,defineScene,withDependencies};

package/dist/definition/group.d.ts

@@ -0,0 +1,2 @@
+import type { CallableDefinition, EmptyResources } from './callable.js';
+export type GroupDefinition<Input, Output, Resources extends object = EmptyResources, Delta = never> = CallableDefinition<Input, Output, 'group', Resources, Delta>;

package/dist/definition/group.js

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

package/dist/definition/kind.d.ts

@@ -0,0 +1,7 @@
+import type { CallableKind } from '@weiliang0121/capix-contracts';
+export declare const childKinds: {
+    readonly scene: readonly ["group", "node"];
+    readonly group: readonly ["group", "node"];
+    readonly node: readonly [];
+};
+export type ChildKind<Kind extends CallableKind> = (typeof childKinds)[Kind][number];

package/dist/definition/kind.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+const childKinds={scene:["group","node"],group:["group","node"],node:[]};export{childKinds};

package/dist/definition/node.d.ts

@@ -0,0 +1,2 @@
+import type { CallableDefinition, EmptyResources } from './callable.js';
+export type NodeDefinition<Input, Output, Resources extends object = EmptyResources, Delta = never> = CallableDefinition<Input, Output, 'node', Resources, Delta>;

package/dist/definition/node.js

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

package/dist/definition/reception.d.ts

@@ -0,0 +1,8 @@
+import type { CallableKind, ReceptionValue, ReceptionDefinition, ReceptionRegistration, ChildContract } from '@weiliang0121/capix-contracts';
+import type { ChildContractsOf } from './children.js';
+export type DefinitionReceptions<Kind extends CallableKind> = Kind extends 'node' ? never : readonly ReceptionRegistration<ChildContractsOf<Kind>>[];
+type SynchronousCheck<Check extends (value: unknown) => unknown> = [Extract<ReturnType<Check>, PromiseLike<unknown>>] extends [never] ? unknown : never;
+export declare function reception<Definition extends ChildContract, Check extends (value: unknown) => unknown>(child: Definition, value: {
+    readonly check: Check;
+} & NoInfer<Omit<ReceptionValue<ReturnType<Check>>, 'check'>> & SynchronousCheck<Check>): ReceptionDefinition<Definition, ReturnType<Check>>;
+export {};

package/dist/definition/reception.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 reception(child,value){return Object.freeze({child,value})}__name(reception,"reception");export{reception};

package/dist/definition/scene.d.ts

@@ -0,0 +1,2 @@
+import type { CallableDefinition, EmptyResources } from './callable.js';
+export type SceneDefinition<Input, Output, Resources extends object = EmptyResources, Delta = never> = CallableDefinition<Input, Output, 'scene', Resources, Delta>;

package/dist/definition/scene.js

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

package/dist/definition/work.d.ts

@@ -0,0 +1,16 @@
+import type { CallableKind, Work, CompositeWork, ChildContract, AuthorCheckpointWriter, ContinuationFact, OutputWork } from '@weiliang0121/capix-contracts';
+import type { ChildContractsOf } from './children.js';
+type Children<Kind extends CallableKind, Allowed extends ChildContractsOf<Kind>, Restoring extends boolean> = Kind extends 'node' ? object : CompositeWork<Allowed, Restoring>;
+export type CallableWork<Kind extends CallableKind, Input, Output, Resources extends object = Record<string, never>, Allowed extends ChildContractsOf<Kind> = ChildContractsOf<Kind>, Delta = never> = Work<Input, Resources> & Children<Kind, Allowed, false> & OutputWork<Delta> & {
+    readonly checkpoint?: AuthorCheckpointWriter<Kind, Input, Output, Delta>;
+};
+export type ResumeWork<Kind extends CallableKind, Input, Output, Resources extends object = Record<string, never>, Allowed extends ChildContractsOf<Kind> = ChildContractsOf<Kind>, Delta = never> = Work<Input, Resources> & Children<Kind, Allowed, true> & OutputWork<Delta> & {
+    readonly initialInput: Input;
+    readonly round: 1 | 2;
+    readonly continuation?: ContinuationFact;
+    readonly checkpoint?: AuthorCheckpointWriter<Kind, Input, Output, Delta>;
+};
+export type SceneWork<Input, Output, Resources extends object = Record<string, never>, Allowed extends ChildContract = ChildContract, Delta = never> = CallableWork<'scene', Input, Output, Resources, Allowed, Delta>;
+export type GroupWork<Input, Output, Resources extends object = Record<string, never>, Allowed extends ChildContract = ChildContract, Delta = never> = CallableWork<'group', Input, Output, Resources, Allowed, Delta>;
+export type NodeWork<Input, Output, Resources extends object = Record<string, never>, Delta = never> = CallableWork<'node', Input, Output, Resources, never, Delta>;
+export {};

package/dist/definition/work.js

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

package/dist/group.d.ts

@@ -0,0 +1,13 @@
+import { Callable } from './callable.js';
+import type { GroupDefinition } from './definition/group.js';
+import type { Composite, NamedMembers, MemberRegistration, NamedMemberRegistration } from './definition/composition.js';
+import type { ChildCallable } from './definition/children.js';
+import type { EmptyResources } from './definition/callable.js';
+export declare class Group<Input = unknown, Output = unknown, Resources extends object = EmptyResources, Delta = never> extends Callable<Input, Output, 'group', Resources, Delta> implements Composite {
+    #private;
+    get names(): NamedMembers;
+    get members(): readonly ChildCallable[];
+    constructor(definition?: GroupDefinition<Input, Output, Resources, Delta>);
+    add<const Names extends NamedMembers>(members: MemberRegistration<Names>): this & NamedMemberRegistration<Names>;
+    add(...members: readonly ChildCallable[]): this;
+}

package/dist/group.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{Callable}from"./callable.js";import{appendMembers,appendNamedMembers,requireChildCallable}from"./members.js";import{assertStructureConfigurable}from"./configuration.js";class Group extends Callable{static{__name(this,"Group")}#members=Object.freeze([]);#names=Object.freeze({});get names(){return this.#names}get members(){return this.#members}constructor(definition){super("group",definition)}add(...members){if(assertStructureConfigurable(this),members.length===1&&!(members[0]instanceof Callable)){const next=appendNamedMembers(this,this.#members,this.#names,members[0]);this.#members=next.members,this.#names=next.names}else{const additions=[];for(const member of members)requireChildCallable(member),additions.push(member);this.#members=appendMembers(this,this.#members,additions)}return this}}export{Group};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from './callable.js';
+export * from './scene.js';
+export * from './group.js';
+export * from './node.js';
+export * from './definition/composition.js';
+export type { ChildKind } from './definition/kind.js';
+export * from './definition/callable.js';
+export * from './definition/scene.js';
+export * from './definition/group.js';
+export * from './definition/node.js';
+export * from './definition/factory.js';
+export * from './definition/work.js';
+export * from './definition/children.js';
+export * from './definition/checkpoint.js';
+export * from './definition/reception.js';
+export * from './composition/sequence.js';
+export type { AuthorCheckpointWriter, BusinessEvent, CallableContract, CallableDelta, CallableInput, CallableKind, CallableOutput, CallableShape, CheckpointCodec, CheckpointContract, CheckpointFacts, CheckpointPointOwner, CheckpointOccurrence, CheckpointReferenceSlots, CheckpointSelection, CheckpointWriteReferences, CheckpointValue, ChildCall, ChildCalls, ChildContract, ChildFact, ChildFacts, ChildInvocationOptions, ChildInvocationReceptionOptions, ChildOperationOptions, ChildOptions, ChildReceptionOptions, ChildReference, ChildReferenceSlot, ChildReturnFact, CompositeWork, ContinuationFact, ExceptionOrigin, InvocationOutputEvent, InvocationOutputReceiver, InvocationOutputWriter, InvocationSignature, OutputDeclaration, ProgressReceiver, ReceptionDefinition, ReceptionRegistration, ReceptionValue, ResumeChildCalls, SavedReferenceFacts, SavedReferences, Work, invocationSignature } from '@weiliang0121/capix-contracts';
+export * from './composition/dynamic.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+/*! MIT License | Copyright (c) 2026 wei.liang | See LICENSE */
+export*from"./callable.js";export*from"./scene.js";export*from"./group.js";export*from"./node.js";export*from"./definition/composition.js";export*from"./definition/callable.js";export*from"./definition/scene.js";export*from"./definition/group.js";export*from"./definition/node.js";export*from"./definition/factory.js";export*from"./definition/work.js";export*from"./definition/children.js";export*from"./definition/checkpoint.js";export*from"./definition/reception.js";export*from"./composition/sequence.js";export*from"./composition/dynamic.js";

package/dist/members.d.ts

@@ -0,0 +1,13 @@
+import type { ChildCallable } from './definition/children.js';
+import type { NamedMembers } from './definition/composition.js';
+export declare function requireChildCallable(value: unknown): asserts value is ChildCallable;
+export declare function appendMembers(owner: {
+    readonly kind: 'scene' | 'group';
+}, current: readonly ChildCallable[], additions: readonly ChildCallable[]): readonly ChildCallable[];
+export declare function checkMemberName(name: string): void;
+export declare function appendNamedMembers(owner: {
+    readonly kind: 'scene' | 'group';
+}, current: readonly ChildCallable[], names: NamedMembers, additions: unknown): {
+    readonly members: readonly ChildCallable[];
+    readonly names: NamedMembers;
+};

package/dist/members.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{types}from"node:util";import{Callable}from"./callable.js";import{assertStructureConfigurable,claimStructureMembers}from"./configuration.js";function requireChildCallable(value){if(types.isProxy(value))throw new TypeError("Callable structures cannot be proxies");if(!(value instanceof Callable)||value.kind!=="node"&&!(value.kind==="group"&&"members"in value&&Array.isArray(value.members)))throw new TypeError("Members must be Group or Node objects")}__name(requireChildCallable,"requireChildCallable");function appendMembers(owner,current,additions){for(const member of additions){if(!(member instanceof Callable)||member.kind!=="group"&&member.kind!=="node")throw new TypeError("Members must be Group or Node objects");const visit=__name((candidate,path)=>{if(candidate===owner||path.has(candidate))throw new Error("Cyclic callable membership");if(candidate.kind!=="node"){path.add(candidate);for(const child of candidate.members)visit(child,path);path.delete(candidate)}},"visit");visit(member,new Set)}const next=[...current];for(const member of additions)next.includes(member)||next.push(member);const members=Object.freeze(next);return claimStructureMembers(owner,additions),members}__name(appendMembers,"appendMembers");const reservedNames=new Set(["invoke","create","open","facts","resume","prototype",...Object.getOwnPropertyNames(Object.prototype)]);function checkMemberName(name){if(!name||reservedNames.has(name))throw new TypeError(`Member name is reserved or empty: ${name}`)}__name(checkMemberName,"checkMemberName");function appendNamedMembers(owner,current,names,additions){if(!additions||typeof additions!="object"||Array.isArray(additions)||types.isProxy(additions))throw new TypeError("Named members must be an object");if(Object.getOwnPropertySymbols(additions).length)throw new TypeError("Member names must be strings");const entries=[];for(const[name,descriptor]of Object.entries(Object.getOwnPropertyDescriptors(additions))){if(!("value"in descriptor))throw new TypeError("Named members must use data properties");const member=descriptor.value;if(requireChildCallable(member),entries.push([name,member]),checkMemberName(name),Object.hasOwn(names,name)&&names[name]!==member)throw new Error(`Member name already belongs to another member: ${name}`)}const nextNames=Object.freeze({...names,...Object.fromEntries(entries)});return assertStructureConfigurable(owner),{members:appendMembers(owner,current,entries.map(([,member])=>member)),names:nextNames}}__name(appendNamedMembers,"appendNamedMembers");export{appendMembers,appendNamedMembers,checkMemberName,requireChildCallable};

package/dist/node.d.ts

@@ -0,0 +1,7 @@
+import { Callable } from './callable.js';
+import type { NodeDefinition } from './definition/node.js';
+import type { EmptyResources } from './definition/callable.js';
+export declare class Node<Input = unknown, Output = unknown, Resources extends object = EmptyResources, Delta = never> extends Callable<Input, Output, 'node', Resources, Delta> {
+    readonly members?: never;
+    constructor(definition?: NodeDefinition<Input, Output, Resources, Delta>);
+}

package/dist/node.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{Callable}from"./callable.js";class Node extends Callable{static{__name(this,"Node")}constructor(definition){super("node",definition)}}export{Node};

package/dist/scene.d.ts

@@ -0,0 +1,15 @@
+import { Callable } from './callable.js';
+import type { SceneDefinition } from './definition/scene.js';
+import type { Composite, NamedMembers, MemberRegistration, NamedMemberRegistration } from './definition/composition.js';
+import type { ChildCallable } from './definition/children.js';
+import type { EmptyResources } from './definition/callable.js';
+import type { CallableContract } from '@weiliang0121/capix-contracts';
+export declare class Scene<Input = unknown, Output = unknown, Resources extends object = EmptyResources, Delta = never> extends Callable<Input, Output, 'scene', Resources, Delta> implements Composite {
+    #private;
+    get names(): NamedMembers;
+    get members(): readonly ChildCallable[];
+    constructor(child: ChildCallable & CallableContract<'group' | 'node', Input, Output, unknown>);
+    constructor(definition?: SceneDefinition<Input, Output, Resources, Delta>);
+    add<const Names extends NamedMembers>(members: MemberRegistration<Names>): this & NamedMemberRegistration<Names>;
+    add(...members: readonly ChildCallable[]): this;
+}

package/dist/scene.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{Callable}from"./callable.js";import{appendMembers,appendNamedMembers,requireChildCallable}from"./members.js";import{assertStructureConfigurable}from"./configuration.js";class Scene extends Callable{static{__name(this,"Scene")}#members=Object.freeze([]);#names=Object.freeze({});get names(){return this.#names}get members(){return this.#members}constructor(definition){definition instanceof Callable?(requireChildCallable(definition),super("scene"),this.add(definition),this.run=async work=>await work.children.invoke(definition,work.input)):super("scene",definition)}add(...members){if(assertStructureConfigurable(this),members.length===1&&!(members[0]instanceof Callable)){const next=appendNamedMembers(this,this.#members,this.#names,members[0]);this.#members=next.members,this.#names=next.names}else{const additions=[];for(const member of members)requireChildCallable(member),additions.push(member);this.#members=appendMembers(this,this.#members,additions)}return this}}export{Scene};

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@weiliang0121/capix-structure",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./construction": {
+      "types": "./dist/construction.d.ts",
+      "import": "./dist/construction.js"
+    }
+  },
+  "dependencies": {
+    "@weiliang0121/capix-resources": "0.1.0",
+    "@weiliang0121/capix-contracts": "0.1.0"
+  },
+  "description": "Composable Scene, Group, and Node structures for CAPiX.",
+  "license": "MIT",
+  "author": "wei.liang (https://github.com/weiliang0121)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weiliang0121/capix.git",
+    "directory": "server/structure"
+  },
+  "engines": {
+    "node": ">=22.23.2"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
 }