@mica-js/device-model 0.0.0-stage → 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,1053 @@
+export declare type Argument = Operand<RuntimeValue> | PinRef | MemoryRef;
+
+export declare type ArgumentIR = {
+    readonly kind: 'value';
+    readonly value: ResultId;
+} | PinRefIR | MemoryRefIR;
+
+/** 消息回调生成惰性区域，运行时只在条件为 false 时计算消息。 */
+export declare interface Assertions<Compute extends ValueOps> {
+    assert(condition: Operand<boolean>, message?: (body: Compute) => ComputeResult<Compute, string>): void;
+}
+
+export declare type BinaryOperator = 'add' | 'subtract' | 'multiply' | 'divide' | 'remainder' | 'power' | 'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'equal' | 'notEqual' | 'concat' | 'bitAnd' | 'bitOr' | 'bitXor' | 'shiftLeft' | 'shiftRight' | 'shiftRightUnsigned';
+
+export declare interface BlockIR extends Located {
+    readonly kind: 'block';
+    readonly instructions: readonly InstructionIR[];
+}
+
+export declare class BuildError extends Error {
+    readonly diagnostics: readonly [Diagnostic, ...Diagnostic[]];
+    constructor(diagnostics: readonly [Diagnostic, ...Diagnostic[]]);
+}
+
+declare const bytesTag: unique symbol;
+
+export declare interface BytesValue {
+    readonly [bytesTag]: true;
+}
+
+export declare interface ChannelOptions<T extends RuntimeValue> extends NamedOptions {
+    readonly direction: 'input' | 'output';
+    readonly type: Type<T>;
+    readonly capacity: CreationInput<number>;
+    readonly overflow?: CreationInput<EnumValue<'Overflow', 'drop_new' | 'drop_oldest' | 'error'>>;
+    readonly maxLength?: CreationInput<number>;
+}
+
+export declare type ComparablePlainTypeIR = {
+    readonly kind: 'number' | 'bool' | 'string' | 'bytes' | 'sample';
+} | {
+    readonly kind: 'enum' | 'record';
+    readonly name: string;
+};
+
+export declare type ComparableTypeIR = ComparablePlainTypeIR | {
+    readonly kind: 'optional';
+    readonly inner: ComparablePlainTypeIR;
+};
+
+export declare type ComparableValue = Exclude<RuntimeValue, IntentValue>;
+
+/** 独立计算体使用 returnValue；创建期、derived 或 reaction capture 用途由声明决定。 */
+export declare interface ComputationIR extends Located {
+    readonly type: ValueTypeIR;
+    readonly body: RegionIR;
+}
+
+/** 普通同步计算允许 void，但生成路径必须全部终结；纯与创建期计算仍须返回 Operand。 */
+export declare type ComputeResult<Compute extends ValueOps, T extends RuntimeValue> = Compute extends RuntimeEffects ? Operand<T> | void : Operand<T>;
+
+/** 记录接受目标类型的字段对象；bytes 输入会复制。sample 与 intent 不能伪造宿主常量。 */
+export declare type Constant<T> = T extends IntentValue | SampleValue ? never : T extends BytesValue ? Uint8Array | readonly number[] : T extends RecordValue<string, infer F> ? Readonly<F> : T;
+
+/** 常量保留内存 number 语义，包括 NaN、无穷大与负零；sample 和 intent 不由常量伪造。 */
+export declare type ConstantIR = {
+    readonly kind: 'number';
+    readonly value: number;
+} | {
+    readonly kind: 'bool';
+    readonly value: boolean;
+} | {
+    readonly kind: 'string';
+    readonly value: string;
+} | {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'enum';
+    readonly name: string;
+    readonly member: string;
+} | {
+    readonly kind: 'record';
+    readonly name: string;
+    readonly fields: readonly {
+        readonly name: string;
+        readonly value: number | boolean;
+    }[];
+} | {
+    readonly kind: 'bytes';
+    readonly value: readonly number[];
+};
+
+export declare interface ConstantOptions<T extends RuntimeValue> extends NamedOptions {
+    readonly type: Type<T>;
+    readonly value: NoInfer<CreationInput<T>>;
+}
+
+export declare interface ControlFlow<Self, Test extends ValueOps> extends SourceScope<Self> {
+    local<T extends RuntimeValue>(type: Type<T>, initial: NoInfer<Operand<T>>): Local<T>;
+    setLocal<T extends RuntimeValue>(local: Local<T>, value: NoInfer<Operand<T>>): void;
+    if(condition: Operand<boolean>, yes: (body: Self) => void, no?: (body: Self) => void): void;
+    match<T extends RuntimeValue>(value: Value<T>, arms: readonly NoInfer<MatchArm<T, Self>>[], otherwise?: (body: Self) => void): void;
+    /** 每轮重算条件；条件允许所在上下文合法的同步效果，但不能等待或跳转外层循环。 */
+    while(test: (body: Test) => ComputeResult<Test, boolean>, emit: (body: Self) => void): void;
+    loop(emit: (body: Self) => void): void;
+    break(): void;
+    continue(): void;
+}
+
+export declare function createDeviceBuilder(options: NamedOptions): DeviceBuilder;
+
+/** Runtime integration factory; only existing resources can be referenced by the returned view. */
+export declare function createJitBlockBuilder(options?: JitBuilderOptions): JitBlockBuilder;
+
+export declare interface CreationBody<T extends RuntimeValue> extends CreationStatements<CreationBody<T>> {
+    returnValue(value: Operand<T>): void;
+}
+
+export declare interface CreationCompute extends CreationStatements<CreationCompute> {
+}
+
+/** 构造回调产生创建期 IR，不是实例创建时执行的任意宿主 JS；正常路径须 returnValue。 */
+export declare type CreationInput<T extends RuntimeValue> = Constant<T> | ((body: CreationBody<T>) => void);
+
+export declare interface CreationStatements<Self> extends ValueOps, ControlFlow<Self, CreationCompute>, LazyOps<CreationCompute>, Assertions<CreationCompute> {
+}
+
+/** 声明顺序用于稳定诊断与合同规定的初始化顺序；前向引用统一在完成阶段解析。 */
+export declare type DeclarationIR = Located & ({
+    readonly kind: 'enum';
+    readonly name: string;
+    readonly members: readonly string[];
+} | {
+    readonly kind: 'record';
+    readonly name: string;
+    readonly fields: readonly {
+        readonly name: string;
+        readonly type: 'number' | 'bool';
+    }[];
+} | {
+    readonly kind: 'property';
+    readonly name: string;
+    readonly type: ValueTypeIR;
+    readonly default?: ComputationIR;
+} | {
+    readonly kind: 'const';
+    readonly name: string;
+    readonly type: ValueTypeIR;
+    readonly value: ComputationIR;
+} | {
+    readonly kind: 'state';
+    readonly name: string;
+    readonly type: ValueTypeIR;
+    readonly initial: ComputationIR;
+} | {
+    readonly kind: 'derived';
+    readonly name: string;
+    readonly type: ValueTypeIR;
+    readonly value: ComputationIR;
+} | ({
+    readonly kind: 'pin';
+    readonly name: string;
+    /** 创建期求值；省略为空意图，后续 writeIntent 完整替换。 */
+    readonly initial?: ComputationIR & {
+        readonly type: {
+            readonly kind: 'intent';
+        };
+    };
+} & ({
+    readonly low?: never;
+    readonly high?: never;
+} | {
+    readonly low: ComputationIR;
+    readonly high: ComputationIR;
+})) | {
+    readonly kind: 'memory';
+    readonly name: string;
+    readonly public: boolean;
+    readonly length: ComputationIR;
+} | {
+    readonly kind: 'channel';
+    readonly name: string;
+    readonly direction: 'input' | 'output';
+    readonly type: ValueTypeIR;
+    readonly capacity: ComputationIR;
+    readonly maxLength?: ComputationIR;
+    readonly overflow?: ComputationIR;
+} | {
+    readonly kind: 'notification';
+    readonly name: string;
+    readonly direction: 'input' | 'output';
+} | {
+    readonly kind: 'function';
+    readonly name: string;
+    readonly pure: boolean;
+    readonly params: readonly ParameterIR[];
+    readonly returns?: ValueTypeIR;
+    readonly body: RegionIR;
+} | {
+    readonly kind: 'start';
+    readonly body: RegionIR;
+} | {
+    readonly kind: 'reaction';
+    readonly name: string;
+    readonly sourcePath: readonly [string, ...string[]];
+    readonly sourceType: ComparableTypeIR;
+    readonly previous: string;
+    readonly current: string;
+    readonly captures: readonly ReactionCaptureIR[];
+    readonly body: RegionIR;
+} | {
+    readonly kind: 'on';
+    readonly name: string;
+    readonly sourcePath: readonly string[];
+    readonly body: RegionIR;
+} | {
+    readonly kind: 'assert';
+    readonly body: RegionIR;
+});
+
+/** 静态声明可前向引用；回调结束即关闭其体 Builder，完成或失败后关闭整个定义 Builder。 */
+export declare interface DeviceBuilder extends SourceScope<DeviceBuilder> {
+    enum<const N extends string, const M extends readonly [string, ...string[]]>(options: {
+        readonly name: N;
+        readonly members: M;
+        readonly source?: SourceInfo;
+    }): EnumType<N, M>;
+    record<const N extends string, const F extends RecordFields>(options: {
+        readonly name: N;
+        readonly fields: F;
+        readonly source?: SourceInfo;
+    }): RecordType<N, F>;
+    property<T extends RuntimeValue>(options: PropertyOptions<T>): void;
+    constant<T extends RuntimeValue>(options: ConstantOptions<T>): void;
+    state<T extends RuntimeValue>(options: InitialOptions<T>): void;
+    derived<T extends RuntimeValue>(options: NamedOptions & {
+        readonly type: Type<T>;
+    }, emit: (body: NoInfer<PureValueFunctionBody<T>>) => void): void;
+    pin(options: PinOptions): void;
+    memory(options: MemoryOptions): void;
+    channel<T extends RuntimeValue>(options: ChannelOptions<T>): void;
+    notification(options: NamedOptions & {
+        readonly direction: 'input' | 'output';
+    }): void;
+    fn<const P extends readonly Parameter[]>(options: FunctionOptions<P> & {
+        readonly returns?: never;
+    }, emit: (body: VoidFunctionBody, args: ParameterBindings<P>) => void): void;
+    fn<const P extends readonly Parameter[], T extends RuntimeValue>(options: FunctionOptions<P> & {
+        readonly returns: Type<T>;
+    }, emit: (body: ValueFunctionBody<T>, args: ParameterBindings<P>) => void): void;
+    pureFn<const P extends readonly Parameter[]>(options: FunctionOptions<P> & {
+        readonly returns?: never;
+    }, emit: (body: PureVoidFunctionBody, args: ParameterBindings<P>) => void): void;
+    pureFn<const P extends readonly Parameter[], T extends RuntimeValue>(options: FunctionOptions<P> & {
+        readonly returns: Type<T>;
+    }, emit: (body: PureValueFunctionBody<T>, args: ParameterBindings<P>) => void): void;
+    start(emit: (body: ProcessBody) => void): void;
+    on(options: NamedOptions & {
+        readonly sourcePath: readonly [string, ...string[]];
+    }, emit: (body: ProcessBody) => void): void;
+    /** capture 回调各自生成独立纯计算体；响应参数为生成的 IR 结果句柄。 */
+    reaction<T extends ComparableValue, const C extends readonly ReactionCapture[]>(options: ReactionOptions<T, C>, capture: NoInfer<ReactionCaptureEmitters<C>>, emit: (body: ReactionBody, bindings: NoInfer<ReactionBindings<T, C>>) => void): void;
+    assert(emit: (body: CreationCompute) => void): void;
+    finish(): DeviceIR;
+}
+
+export declare interface DeviceIR extends Located {
+    readonly kind: 'device';
+    readonly name: string;
+    readonly declarations: readonly DeclarationIR[];
+}
+
+/** path 定位当前输入，source 定位原始来源；message 和相关说明使用英文。 */
+export declare interface Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly message: string;
+    readonly phase: DiagnosticPhase;
+    readonly path: InputPath;
+    readonly source?: SourceInfo;
+    readonly related: readonly RelatedDiagnostic[];
+}
+
+export declare type DiagnosticCode = 'IR_SCHEMA' | 'IR_TYPE' | 'IR_SCOPE' | 'IR_CONTROL_FLOW' | 'IR_EFFECT' | 'IR_REFERENCE' | 'IR_LIFECYCLE' | 'IR_DEPENDENCY' | 'IR_JIT_BOUNDARY';
+
+export declare type DiagnosticPhase = 'construct' | 'finalize' | 'bind';
+
+declare const enumTag: unique symbol;
+
+export declare interface EnumType<N extends string, M extends readonly string[]> extends Type<EnumValue<N, M[number]>> {
+    readonly name: N;
+    readonly members: {
+        readonly [K in M[number]]: EnumValue<N, K>;
+    };
+}
+
+export declare interface EnumValue<N extends string, M extends string = string> {
+    readonly [enumTag]: {
+        readonly name: N;
+        readonly member: M;
+    };
+}
+
+export declare type FieldShape = Readonly<Record<string, number | boolean>>;
+
+export declare type FieldValues<F extends RecordFields> = {
+    readonly [K in keyof F]: Infer<F[K]>;
+};
+
+export declare interface FunctionOptions<P extends readonly Parameter[]> {
+    readonly name: string;
+    readonly params: P;
+    readonly source?: SourceInfo;
+}
+
+export declare type Infer<T> = T extends Type<infer V> ? V : never;
+
+export declare interface InitialIntentBody extends InitialIntentStatements<InitialIntentBody> {
+    returnValue(value: Operand<IntentValue>): void;
+}
+
+export declare interface InitialIntentCompute extends InitialIntentStatements<InitialIntentCompute> {
+}
+
+/** pin.initial 专用能力；嵌套计算保持相同的创建期限制。 */
+export declare interface InitialIntentStatements<Self> extends ValueOps, PinIntentOps, ControlFlow<Self, InitialIntentCompute>, LazyOps<InitialIntentCompute>, Assertions<InitialIntentCompute> {
+}
+
+export declare interface InitialOptions<T extends RuntimeValue> extends NamedOptions {
+    readonly type: Type<T>;
+    readonly initial: NoInfer<CreationInput<T>>;
+}
+
+export declare type InputPath = readonly (string | number)[];
+
+export declare interface InstructionBoundary {
+    readonly pc: number;
+    readonly nextPc: number;
+    readonly source?: SourceInfo;
+}
+
+/** pc / nextPc 是有限 number，不要求整数或递增；每条指令拥有独立局部编号空间。 */
+export declare interface InstructionIR extends Located {
+    readonly pc: number;
+    readonly nextPc: number;
+    readonly body: RegionIR;
+}
+
+declare const intentTag: unique symbol;
+
+export declare interface IntentValue {
+    readonly [intentTag]: true;
+}
+
+/** 仅由当前实例的翻译上下文提供，不能通过此视图新增资源或入口。 */
+export declare interface JitBlockBuilder extends SourceScope<JitBlockBuilder> {
+    instruction(boundary: InstructionBoundary, emit: (body: JitInstructionBuilder) => void): void;
+    finish(): BlockIR;
+}
+
+declare interface JitBuilderOptions {
+    readonly device?: DeviceIR;
+    readonly source?: SourceInfo;
+}
+
+export declare interface JitInstructionBuilder extends RuntimeStatements<JitInstructionBuilder, SyncCompute>, RedirectEffect {
+    /** 显式耗时阶段，执行到该处捕获动态时长，等待期间不随资源变化重新计算。 */
+    elapse(duration: Operand<number>): void;
+    /** 绑定无参 bool pure fn；仅指令及块的尾路径允许，循环内拒绝。 */
+    waitUntil(predicate: string): void;
+    /** 终结路径并停止当前注册；新板独立注册，不同于结束块构造的 finish。 */
+    stop(): void;
+}
+
+/** 回调在构造期运行一次；生成的计算区域只在对应运行路径求值，不允许挂起。 */
+export declare interface LazyOps<Compute extends ValueOps> {
+    and(left: Operand<boolean>, right: (body: Compute) => ComputeResult<Compute, boolean>): Value<boolean>;
+    or(left: Operand<boolean>, right: (body: Compute) => ComputeResult<Compute, boolean>): Value<boolean>;
+    select<T extends RuntimeValue>(type: Type<T>, condition: Operand<boolean>, yes: (body: Compute) => NoInfer<ComputeResult<Compute, T>>, no: (body: Compute) => NoInfer<ComputeResult<Compute, T>>): Value<T>;
+}
+
+export declare type LoadKind = 'load8' | 'load16le' | 'load16be' | 'load32le' | 'load32be';
+
+/** 可变局部槽显式读写；类型不变，且不得跨独立执行体或 JIT 指令使用。 */
+export declare interface Local<T> {
+    readonly [localTag]: (value: T) => T;
+}
+
+/** 与结果分开编号；编号相同不表示可以跨作用域共享局部槽。 */
+export declare type LocalId = number;
+
+declare const localTag: unique symbol;
+
+export declare interface Located {
+    readonly source?: SourceInfo;
+}
+
+export declare interface MatchArm<T, Self> {
+    readonly pattern: MatchPattern<T>;
+    readonly emit: (body: Self) => void;
+}
+
+export declare interface MatchArmIR extends Located {
+    readonly pattern: MatchPatternIR;
+    readonly body: RegionIR;
+}
+
+export declare type MatchPattern<T> = T extends number | string | boolean | null | EnumValue<string> ? T : never;
+
+export declare type MatchPatternIR = {
+    readonly kind: 'number';
+    readonly value: number;
+} | {
+    readonly kind: 'string';
+    readonly value: string;
+} | {
+    readonly kind: 'bool';
+    readonly value: boolean;
+} | {
+    readonly kind: 'enum';
+    readonly name: string;
+    readonly member: string;
+} | {
+    readonly kind: 'none';
+};
+
+export declare type MemoryInput = string | MemoryRef;
+
+export declare interface MemoryOptions extends NamedOptions {
+    readonly public?: boolean;
+    readonly length: CreationInput<number>;
+}
+
+export declare interface MemoryParameterType {
+    readonly kind: 'memory';
+}
+
+export declare interface MemoryRef {
+    readonly [refTag]: 'memory';
+}
+
+export declare type MemoryRefIR = {
+    readonly kind: 'memory';
+    readonly name: string;
+} | {
+    readonly kind: 'parameter';
+    readonly resource: 'memory';
+    readonly index: number;
+};
+
+export declare interface NamedOptions {
+    readonly name: string;
+    readonly source?: SourceInfo;
+}
+
+export declare type NumericBuiltin = 'isNaN' | 'isFinite' | 'isInteger' | 'isSafeInteger' | 'abs' | 'floor' | 'ceil' | 'trunc' | 'round' | 'sqrt' | 'min' | 'max' | 'pow';
+
+export declare type Operand<T> = Value<T> | Constant<T>;
+
+/**
+ * 普通值输入全部为 ResultId，资源与局部槽使用各自字段。
+ * 结果 type 和 call.pure 都是待核对信息，不能替代对实际节点及调用图的检查。
+ * wait / elapse / redirect 的时间值均在执行到操作时读取，单位为整数皮秒。
+ */
+export declare type OperationIR = Located & ((ResultIR & {
+    readonly kind: 'constant';
+    readonly constant: ConstantIR;
+}) | (ResultIR & {
+    readonly kind: 'read';
+    readonly resource: 'property' | 'const' | 'state' | 'derived';
+    readonly name: string;
+}) | (ResultIR & {
+    readonly kind: 'parameter';
+    readonly index: number;
+}) | (ResultIR & {
+    readonly kind: 'reactionValue';
+    readonly binding: 'previous' | 'current';
+}) | (ResultIR & {
+    readonly kind: 'reactionCapture';
+    readonly index: number;
+}) | (ResultIR & {
+    readonly kind: 'unary';
+    readonly operator: UnaryOperator;
+    readonly value: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'binary';
+    readonly operator: BinaryOperator;
+    readonly left: ResultId;
+    readonly right: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'numeric';
+    readonly builtin: NumericBuiltin;
+    readonly args: readonly ResultId[];
+}) | (ResultIR & {
+    readonly kind: 'record';
+    readonly fields: readonly {
+        readonly name: string;
+        readonly value: ResultId;
+    }[];
+}) | (ResultIR & {
+    readonly kind: 'field';
+    readonly value: ResultId;
+    readonly field: string;
+}) | (ResultIR & {
+    readonly kind: 'bytes';
+    readonly elements: readonly ResultId[];
+}) | (ResultIR & {
+    readonly kind: 'length';
+    readonly value: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'index';
+    readonly value: ResultId;
+    readonly index: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'optional';
+    readonly value: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'isNone';
+    readonly value: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'nonNull';
+    readonly value: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'localRead';
+    readonly local: LocalId;
+})
+/** 声明执行时初始化；localRead 捕获一次值，localWrite 不会刷新已保存的旧结果。 */
+| {
+    readonly kind: 'local';
+    readonly local: LocalId;
+    readonly type: ValueTypeIR;
+    readonly initial: ResultId;
+} | {
+    readonly kind: 'localWrite';
+    readonly local: LocalId;
+    readonly value: ResultId;
+}
+/** 执行处立即更新状态，后续 read 可见；不改变先前已捕获的结果。 */
+| {
+    readonly kind: 'write';
+    readonly resource: 'state';
+    readonly name: string;
+    readonly value: ResultId;
+} | (ResultIR & {
+    readonly kind: 'memoryLength';
+    readonly memory: MemoryRefIR;
+}) | (ResultIR & {
+    readonly kind: LoadKind;
+    readonly memory: MemoryRefIR;
+    readonly offset: ResultId;
+}) | {
+    readonly kind: StoreKind;
+    readonly memory: MemoryRefIR;
+    readonly offset: ResultId;
+    readonly value: ResultId;
+} | (ResultIR & {
+    readonly kind: 'copyBytes';
+    readonly memory: MemoryRefIR;
+    readonly offset: ResultId;
+    readonly length: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'readSample';
+    readonly pin: PinRefIR;
+}) | (ResultIR & {
+    readonly kind: 'resistor';
+    readonly to: TargetRefIR;
+    readonly resistance: ResultId;
+}) | (ResultIR & {
+    readonly kind: 'combineIntents';
+    readonly values: readonly ResultId[];
+}) | (ResultIR & {
+    readonly kind: 'refEqual';
+    readonly left: PinRefIR | MemoryRefIR;
+    readonly right: PinRefIR | MemoryRefIR;
+}) | {
+    readonly kind: 'writeIntent';
+    readonly pin: PinRefIR;
+    readonly value: ResultId;
+}
+/** args 按形参顺序引用已求得结果；值的求值顺序由前序操作决定，pure 要核对实际目标。 */
+| {
+    readonly kind: 'call';
+    readonly name: string;
+    readonly pure: boolean;
+    readonly args: readonly ArgumentIR[];
+} | (ResultIR & {
+    readonly kind: 'callValue';
+    readonly name: string;
+    readonly pure: boolean;
+    readonly args: readonly ArgumentIR[];
+}) | {
+    readonly kind: 'send';
+    readonly channel: string;
+    readonly value: ResultId;
+} | {
+    readonly kind: 'notify';
+    readonly notification: string;
+} | (ResultIR & {
+    readonly kind: 'receive';
+    readonly channel: string;
+}) | (ResultIR & {
+    readonly kind: 'now' | 'random';
+}) | {
+    readonly kind: 'if';
+    readonly condition: ResultId;
+    readonly yes: RegionIR;
+    readonly no?: RegionIR;
+} | {
+    readonly kind: 'match';
+    readonly value: ResultId;
+    readonly arms: readonly MatchArmIR[];
+    readonly otherwise?: RegionIR;
+}
+/** 条件每轮重算，允许当前上下文合法同步效果；continue 回到 test，条件不能挂起。 */
+| {
+    readonly kind: 'while';
+    readonly test: ValueRegionIR;
+    readonly body: RegionIR;
+} | {
+    readonly kind: 'loop';
+    readonly body: RegionIR;
+} | (ResultIR & {
+    readonly kind: 'and' | 'or';
+    readonly left: ResultId;
+    readonly right: ValueRegionIR;
+}) | (ResultIR & {
+    readonly kind: 'select';
+    readonly condition: ResultId;
+    readonly yes: ValueRegionIR;
+    readonly no: ValueRegionIR;
+}) | {
+    readonly kind: 'assert';
+    readonly condition: ResultId;
+    readonly message?: ValueRegionIR;
+} | {
+    readonly kind: 'wait' | 'elapse';
+    readonly duration: ResultId;
+}
+/** 只在末条 JIT 指令尾路径出现；if / match 外层无后缀，循环或计算区域内拒绝。 */
+| {
+    readonly kind: 'waitUntil';
+    readonly predicate: string;
+} | {
+    readonly kind: 'redirect';
+    readonly target: ResultId;
+    readonly delay: ResultId;
+} | {
+    readonly kind: 'return' | 'break' | 'continue' | 'stop';
+} | {
+    readonly kind: 'returnValue' | 'yield';
+    readonly value: ResultId;
+});
+
+export declare interface Parameter {
+    readonly name: string;
+    readonly type: ParameterType;
+}
+
+/** 数组顺序决定调用位置，回调按参数名取得句柄；重名、遮蔽及归属另由完成检查验证。 */
+export declare type ParameterBindings<P extends readonly Parameter[]> = {
+    readonly [K in P[number] as K['name']]: K['type'] extends Type<infer V> ? Value<V> : K['type'] extends PinParameterType ? PinRef : MemoryRef;
+};
+
+export declare interface ParameterIR extends Located {
+    readonly name: string;
+    readonly type: ParameterTypeIR;
+}
+
+export declare type ParameterType = Type<RuntimeValue> | PinParameterType | MemoryParameterType;
+
+export declare type ParameterTypeIR = ValueTypeIR | {
+    readonly kind: 'pin' | 'memory';
+};
+
+export declare type PinInput = string | PinRef;
+
+/** 引用按名称延迟解析，允许指向同一定义中后声明的 pin。 */
+export declare interface PinIntentOps {
+    pin(name: string): PinRef;
+    /** 生成引脚间电阻构造；执行时校验闭区间 [0.001, 1e9] Ω。 */
+    resistor(to: TargetInput, resistance: Operand<number>): Value<IntentValue>;
+    combineIntents(...values: Operand<IntentValue>[]): Value<IntentValue>;
+}
+
+export declare type PinOptions = NamedOptions & {
+    readonly initial?: (body: InitialIntentBody) => void;
+} & ({
+    readonly low?: never;
+    readonly high?: never;
+} | {
+    readonly low: CreationInput<number>;
+    readonly high: CreationInput<number>;
+});
+
+export declare interface PinParameterType {
+    readonly kind: 'pin';
+}
+
+/** 引用仅标识本实例资源，不是普通值；不能保存到 Local、记录或作为返回值。 */
+export declare interface PinRef {
+    readonly [refTag]: 'pin';
+}
+
+/** parameter.index 指向当前函数参数表，必须核对资源类别；不会产生资源别名值。 */
+export declare type PinRefIR = {
+    readonly kind: 'pin';
+    readonly name: string;
+} | {
+    readonly kind: 'parameter';
+    readonly resource: 'pin';
+    readonly index: number;
+};
+
+export declare type PlainTypeIR = ComparablePlainTypeIR | {
+    readonly kind: 'intent';
+};
+
+/** 共享 IR 的内存合同；可解析的结构仍须经过类型、作用域、效果与绑定检查。 */
+/** 行列从 1 开始，列按 UTF-16 代码单元计数。 */
+export declare interface Position {
+    readonly line: number;
+    readonly column: number;
+}
+
+export declare interface ProcessBody extends RuntimeStatements<ProcessBody, ProcessCompute> {
+    /** 在执行处捕获时长并按整数皮秒校验；实际挂起才结束当前同步片段。 */
+    wait(duration: Operand<number>): void;
+    /** 只绑定 input channel；非空立即完成，空队列才挂起。 */
+    receive<T extends RuntimeValue>(channel: string, type: Type<T>): Value<T>;
+    return(): void;
+}
+
+export declare interface ProcessCompute extends RuntimeStatements<ProcessCompute, ProcessCompute> {
+}
+
+export declare interface PropertyOptions<T extends RuntimeValue> extends NamedOptions {
+    readonly type: Type<T>;
+    readonly default?: NoInfer<CreationInput<T>>;
+}
+
+export declare interface PureCompute extends PureStatements<PureCompute> {
+}
+
+export declare interface PureStatements<Self> extends ReadOps, ControlFlow<Self, PureCompute>, LazyOps<PureCompute>, Assertions<PureCompute> {
+}
+
+export declare interface PureValueFunctionBody<T extends RuntimeValue> extends PureStatements<PureValueFunctionBody<T>> {
+    returnValue(value: Operand<T>): void;
+}
+
+export declare interface PureVoidFunctionBody extends PureStatements<PureVoidFunctionBody> {
+    return(): void;
+}
+
+export declare interface ReactionBindings<T extends ComparableValue, C extends readonly ReactionCapture[]> {
+    readonly previous: Value<T>;
+    readonly current: Value<T>;
+    readonly captures: {
+        readonly [P in C[number] as P['name']]: Value<Infer<P['type']>>;
+    };
+}
+
+/** 同步响应体可产生普通效果；不提供等待、接收或控制转向。 */
+export declare interface ReactionBody extends RuntimeStatements<ReactionBody, ReactionCompute> {
+    return(): void;
+}
+
+export declare interface ReactionCapture {
+    readonly name: string;
+    readonly type: Type<ComparableValue>;
+    readonly source?: SourceInfo;
+}
+
+export declare interface ReactionCaptureBody<T extends ComparableValue> extends PureStatements<ReactionCaptureBody<T>> {
+    returnValue(value: Operand<T>): void;
+}
+
+export declare type ReactionCaptureEmitters<C extends readonly ReactionCapture[]> = {
+    readonly [P in C[number] as P['name']]: (body: ReactionCaptureBody<Infer<P['type']>>) => void;
+};
+
+/** 每个 capture 是独立纯计算体；只在响应体内按声明索引读取其结果。 */
+export declare interface ReactionCaptureIR extends Located {
+    readonly name: string;
+    readonly value: ComputationIR & {
+        readonly type: ComparableTypeIR;
+    };
+}
+
+export declare interface ReactionCompute extends RuntimeStatements<ReactionCompute, ReactionCompute> {
+}
+
+export declare interface ReactionOptions<T extends ComparableValue, C extends readonly ReactionCapture[]> extends NamedOptions {
+    readonly sourcePath: readonly [string, ...string[]];
+    readonly sourceType: Type<T>;
+    readonly previous: string;
+    readonly current: string;
+    readonly captures: C;
+}
+
+export declare interface ReadOps extends ValueOps, PinIntentOps {
+    /** 捕获执行处的当前状态值；此前的 writeState 已即时生效。 */
+    readState<T extends RuntimeValue>(name: string, type: Type<T>): Value<T>;
+    readDerived<T extends RuntimeValue>(name: string, type: Type<T>): Value<T>;
+    memory(name: string): MemoryRef;
+    memoryLength(memory: MemoryInput): Value<number>;
+    load8(memory: MemoryInput, offset: Operand<number>): Value<number>;
+    load16le(memory: MemoryInput, offset: Operand<number>): Value<number>;
+    load16be(memory: MemoryInput, offset: Operand<number>): Value<number>;
+    load32le(memory: MemoryInput, offset: Operand<number>): Value<number>;
+    load32be(memory: MemoryInput, offset: Operand<number>): Value<number>;
+    copyBytes(memory: MemoryInput, offset: Operand<number>, length: Operand<number>): Value<BytesValue>;
+    readSample(pin: PinInput): Value<SampleValue>;
+    refEqual(left: PinRef, right: PinRef): Value<boolean>;
+    refEqual(left: MemoryRef, right: MemoryRef): Value<boolean>;
+}
+
+export declare type RecordFields = Readonly<Record<string, Type<number> | Type<boolean>>>;
+
+declare const recordTag: unique symbol;
+
+export declare interface RecordType<N extends string, F extends RecordFields> extends Type<RecordValue<N, FieldValues<F>>> {
+    readonly name: N;
+    readonly fields: F;
+}
+
+export declare type RecordValue<N extends string, F extends FieldShape> = Readonly<F> & {
+    readonly [recordTag]: {
+        readonly name: N;
+        readonly fields: F;
+    };
+};
+
+export declare interface RedirectEffect {
+    /** 终结当前路径并跨辅助调用层转向；delay 默认零，单位皮秒，目标须为有限数值。 */
+    redirect(target: Operand<number>, delay?: Operand<number>): void;
+}
+
+declare const refTag: unique symbol;
+
+/** 操作数组的顺序就是执行顺序；子区域不能向外泄露其临时结果编号。 */
+export declare interface RegionIR extends Located {
+    readonly operations: readonly OperationIR[];
+}
+
+export declare interface RelatedDiagnostic {
+    readonly message: string;
+    readonly path: InputPath;
+    readonly source?: SourceInfo;
+}
+
+/** 非负安全整数；在独立执行体或单条 JIT 指令内唯一，不是实例资源编号。 */
+export declare type ResultId = number;
+
+export declare interface ResultIR {
+    readonly result: ResultId;
+    readonly type: ValueTypeIR;
+}
+
+/** 字符串目标无法静态推断声明类型；绑定时核对实际资源、消息负载与调用签名。 */
+export declare interface RuntimeEffects {
+    /** 执行处立即更新状态，不等待同步片段结束或延迟提交。 */
+    writeState<T extends RuntimeValue>(name: string, value: Operand<T>): void;
+    store8(memory: MemoryInput, offset: Operand<number>, value: Operand<number>): void;
+    store16le(memory: MemoryInput, offset: Operand<number>, value: Operand<number>): void;
+    store16be(memory: MemoryInput, offset: Operand<number>, value: Operand<number>): void;
+    store32le(memory: MemoryInput, offset: Operand<number>, value: Operand<number>): void;
+    store32be(memory: MemoryInput, offset: Operand<number>, value: Operand<number>): void;
+    writeIntent(pin: PinInput, value: Operand<IntentValue>): void;
+    call(name: string, ...args: Argument[]): void;
+    callValue<T extends RuntimeValue>(name: string, result: Type<T>, ...args: Argument[]): Value<T>;
+    send<T extends RuntimeValue>(channel: string, value: Operand<T>): void;
+    notify(notification: string): void;
+    /** 执行处读取板级整数皮秒，不推进时间；不能跨挂起复用旧读取。 */
+    now(): Value<number>;
+    /** 消耗本实例随机序列；不能消除、提前执行或重排调用。 */
+    random(): Value<number>;
+}
+
+export declare interface RuntimeStatements<Self, Compute extends ValueOps> extends ReadOps, ControlFlow<Self, Compute>, LazyOps<Compute>, Assertions<Compute>, RuntimeEffects {
+}
+
+export declare type RuntimeValue = number | boolean | string | null | EnumValue<string> | RecordValue<string, FieldShape> | BytesValue | IntentValue | SampleValue;
+
+/** 电气合同规定的完整采样状态集合。 */
+export declare type SampleStatusMember = 'valid' | 'floating';
+
+declare const sampleTag: unique symbol;
+
+export declare interface SampleValue {
+    readonly [sampleTag]: true;
+    readonly voltage: number | null;
+    readonly level: EnumValue<'Logic', 'low' | 'high' | 'unknown'>;
+    readonly status: EnumValue<'SampleStatus', SampleStatusMember>;
+}
+
+/** 无源文件的生成代码可只提供标签；有源码位置时 URI 与范围必须同时存在。 */
+export declare type SourceInfo = {
+    readonly uri: string;
+    readonly range: SourceRange;
+    readonly label?: string;
+} | {
+    readonly label: string;
+    readonly uri?: never;
+    readonly range?: never;
+};
+
+/** 左闭右开范围；结束位置不得早于开始位置。 */
+export declare interface SourceRange {
+    readonly start: Position;
+    readonly end: Position;
+}
+
+/** 仅设置默认来源，不新增 IR 操作或局部作用域；退出后恢复外层来源。 */
+export declare interface SourceScope<Self> {
+    withSource(source: SourceInfo, emit: (body: Self) => void): void;
+}
+
+export declare type StoreKind = 'store8' | 'store16le' | 'store16be' | 'store32le' | 'store32be';
+
+export declare interface SyncCompute extends RuntimeStatements<SyncCompute, SyncCompute>, RedirectEffect {
+}
+
+export declare type TargetInput = PinInput;
+
+export declare type TargetRefIR = PinRefIR;
+
+/** 类型描述辅助 TS 推导；具名身份、定义归属及适用位置仍须由 IR 校验。 */
+export declare interface Type<T> {
+    readonly [typeTag]: T;
+}
+
+export declare interface TypeFactory {
+    readonly number: Type<number>;
+    readonly bool: Type<boolean>;
+    readonly string: Type<string>;
+    readonly bytes: Type<BytesValue>;
+    readonly intent: Type<IntentValue>;
+    readonly sample: Type<SampleValue>;
+    readonly pin: PinParameterType;
+    readonly memory: MemoryParameterType;
+    readonly logic: EnumType<'Logic', readonly ['low', 'high', 'unknown']>;
+    /** 浮空为正常采样状态；数值求解失败通过板级故障报告。 */
+    readonly sampleStatus: EnumType<'SampleStatus', readonly ['valid', 'floating']>;
+    readonly overflow: EnumType<'Overflow', readonly ['drop_new', 'drop_oldest', 'error']>;
+    /** 单层可空；null 常量必须有此类目标类型，不能独立推断具名类型。 */
+    optional<T extends Exclude<RuntimeValue, null>>(type: Type<T>): Type<T | null>;
+    /** 前向引用携带预期结构，完成时核对实际声明及定义归属。 */
+    namedEnum<const N extends string, const M extends readonly [string, ...string[]]>(name: N, members: M): EnumType<N, M>;
+    namedRecord<const N extends string, const F extends RecordFields>(name: N, fields: F): RecordType<N, F>;
+}
+
+export declare const types: TypeFactory;
+
+declare const typeTag: unique symbol;
+
+export declare type UnaryOperator = 'positive' | 'negate' | 'not' | 'bitNot';
+
+export declare function validateBlockIR(input: unknown): BlockIR;
+
+/** Adds instance-definition reference and function-signature checks to a structurally valid block. */
+export declare function validateBoundBlockIR(input: unknown, device: DeviceIR): BlockIR;
+
+export declare function validateDeviceIR(input: unknown): DeviceIR;
+
+/** 一次执行结果的句柄，而非以后每次使用都会重新求值的表达式。 */
+export declare interface Value<T> {
+    readonly [valueTag]: T;
+}
+
+export declare interface ValueFunctionBody<T extends RuntimeValue> extends RuntimeStatements<ValueFunctionBody<T>, SyncCompute>, RedirectEffect {
+    returnValue(value: Operand<T>): void;
+}
+
+/** 所有操作按生成位置执行；普通数值运算保留语言规范的 binary64 和 32 位位运算语义。 */
+export declare interface ValueOps {
+    constant<T extends RuntimeValue>(type: Type<T>, value: NoInfer<Constant<T>>): Value<T>;
+    readProperty<T extends RuntimeValue>(name: string, type: Type<T>): Value<T>;
+    readConst<T extends RuntimeValue>(name: string, type: Type<T>): Value<T>;
+    getLocal<T extends RuntimeValue>(local: Local<T>): Value<T>;
+    positive(value: Operand<number>): Value<number>;
+    negate(value: Operand<number>): Value<number>;
+    not(value: Operand<boolean>): Value<boolean>;
+    bitNot(value: Operand<number>): Value<number>;
+    add(left: Operand<number>, right: Operand<number>): Value<number>;
+    subtract(left: Operand<number>, right: Operand<number>): Value<number>;
+    multiply(left: Operand<number>, right: Operand<number>): Value<number>;
+    divide(left: Operand<number>, right: Operand<number>): Value<number>;
+    remainder(left: Operand<number>, right: Operand<number>): Value<number>;
+    power(left: Operand<number>, right: Operand<number>): Value<number>;
+    lessThan(left: Operand<number>, right: Operand<number>): Value<boolean>;
+    lessThanOrEqual(left: Operand<number>, right: Operand<number>): Value<boolean>;
+    greaterThan(left: Operand<number>, right: Operand<number>): Value<boolean>;
+    greaterThanOrEqual(left: Operand<number>, right: Operand<number>): Value<boolean>;
+    /** 按目标类型比较，intent 拒绝内容相等；具名记录、枚举及可空值另做语义校验。 */
+    equal<T extends RuntimeValue>(type: Type<T>, left: NoInfer<Operand<T>>, right: NoInfer<Operand<T>>): Value<boolean>;
+    notEqual<T extends RuntimeValue>(type: Type<T>, left: NoInfer<Operand<T>>, right: NoInfer<Operand<T>>): Value<boolean>;
+    concat(left: Operand<string>, right: Operand<string>): Value<string>;
+    bitAnd(left: Operand<number>, right: Operand<number>): Value<number>;
+    bitOr(left: Operand<number>, right: Operand<number>): Value<number>;
+    bitXor(left: Operand<number>, right: Operand<number>): Value<number>;
+    shiftLeft(left: Operand<number>, right: Operand<number>): Value<number>;
+    shiftRight(left: Operand<number>, right: Operand<number>): Value<number>;
+    shiftRightUnsigned(left: Operand<number>, right: Operand<number>): Value<number>;
+    isNaN(value: Operand<number>): Value<boolean>;
+    isFinite(value: Operand<number>): Value<boolean>;
+    isInteger(value: Operand<number>): Value<boolean>;
+    isSafeInteger(value: Operand<number>): Value<boolean>;
+    abs(value: Operand<number>): Value<number>;
+    floor(value: Operand<number>): Value<number>;
+    ceil(value: Operand<number>): Value<number>;
+    trunc(value: Operand<number>): Value<number>;
+    round(value: Operand<number>): Value<number>;
+    sqrt(value: Operand<number>): Value<number>;
+    min(left: Operand<number>, right: Operand<number>): Value<number>;
+    max(left: Operand<number>, right: Operand<number>): Value<number>;
+    pow(base: Operand<number>, exponent: Operand<number>): Value<number>;
+    record<const N extends string, const F extends RecordFields>(type: RecordType<N, F>, fields: {
+        readonly [K in keyof F]: Operand<Infer<F[K]>>;
+    }): Value<RecordValue<N, FieldValues<F>>>;
+    field<T extends SampleValue | RecordValue<string, FieldShape>, K extends Exclude<keyof T, symbol>>(value: Value<T>, field: K): Value<T[K]>;
+    bytes(...elements: Operand<number>[]): Value<BytesValue>;
+    length(value: Value<string | BytesValue>): Value<number>;
+    index(value: Value<string>, index: Operand<number>): Value<string>;
+    index(value: Value<BytesValue>, index: Operand<number>): Value<number>;
+    optional<T extends Exclude<RuntimeValue, null>>(value: Value<T>): Value<T | null>;
+    isNone<T extends RuntimeValue>(value: Value<T | null>): Value<boolean>;
+    /** 仅接受当前路径已证明非空的值；无证明时拒绝构造，不插入强制解包检查。 */
+    nonNull<T extends Exclude<RuntimeValue, null>>(value: Value<T | null>): Value<T>;
+    /** 目标必须显式声明 pure fn；创建期还要验证调用链不读取运行资源。 */
+    callPure(name: string, ...args: Argument[]): void;
+    callPureValue<T extends RuntimeValue>(name: string, result: Type<T>, ...args: Argument[]): Value<T>;
+}
+
+/** 每条正常结束路径以 yield 交付结果；yield 不结束外层函数，也不让出调度。 */
+export declare interface ValueRegionIR {
+    readonly type: ValueTypeIR;
+    readonly body: RegionIR;
+}
+
+declare const valueTag: unique symbol;
+
+/** 可空只嵌套一层；具体声明位置还须遵守 DDL 的类型适用范围。 */
+export declare type ValueTypeIR = PlainTypeIR | {
+    readonly kind: 'optional';
+    readonly inner: PlainTypeIR;
+};
+
+/** 无值函数仅提供 return，有值函数仅提供 returnValue；JS 自身 return 不生成该操作。 */
+export declare interface VoidFunctionBody extends RuntimeStatements<VoidFunctionBody, SyncCompute>, RedirectEffect {
+    return(): void;
+}
+
+export { }