ngx-blocks-studio 0.0.15 → 0.1.1

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "ngx-blocks-studio",
-  "version": "0.0.15",
+  "version": "0.1.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/winghei/ngx-blocks-studio.git"
+  },
+  "bugs": {
+    "url": "https://github.com/winghei/ngx-blocks-studio/issues"
+  },
+  "homepage": "https://github.com/winghei/ngx-blocks-studio#readme",
   "peerDependencies": {
-    "@angular/common": "^21.0.0",
-    "@angular/core": "^21.0.0",
-    "@angular/router": "^21.0.0",
+    "@angular/common": "^22.0.0",
+    "@angular/core": "^22.0.0",
+    "@angular/router": "^22.0.0",
     "rxjs": "^7.0.0"
   },
   "dependencies": {
-    "tslib": "^2.3.0",
-    "zod": "^4.0.0"
+    "tslib": "^2.3.0"
   },
   "sideEffects": false,
   "module": "fesm2022/ngx-blocks-studio.mjs",
@@ -22,5 +29,6 @@
       "types": "./types/ngx-blocks-studio.d.ts",
       "default": "./fesm2022/ngx-blocks-studio.mjs"
     }
-  }
+  },
+  "type": "module"
 }

package/types/ngx-blocks-studio.d.ts

@@ -1,7 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { Type, Injector, Signal, ViewContainerRef, ComponentRef } from '@angular/core';
 import { CanActivateFn, RunGuardsAndResolvers } from '@angular/router';
-import { z } from 'zod';
 
 /**
  * Registry entry type: component, service, guard, directive, or block definition.
@@ -310,88 +309,157 @@ declare class RouteLoader {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<RouteLoader>;
 }
 
+interface CurrentInstance {
+    model?: Signal<unknown>;
+    /**
+     * Services/state exposed by name for ref/expression resolution.
+     * (Kept separate from `model` to avoid alias collisions.)
+     */
+    services: Record<string, unknown>;
+}
+/**
+ * Handle for a registered block: exposes instance (services/state by name) for ref resolution.
+ */
+interface BlockInstanceHandle {
+    /** Instance: services and state by name (e.g. FormState, value). */
+    instance: CurrentInstance;
+    /** Optional cleanup when block is destroyed. */
+    destroy?: () => void;
+}
+/**
+ * Registry of block instances by (full) id within a tree.
+ * One registry per logical tree; duplicate id throws.
+ */
+interface BlockRegistry {
+    register(id: string, handle: BlockInstanceHandle): void;
+    unregister(id: string): void;
+    get(id: string): BlockInstanceHandle | undefined;
+    /** True if id resolves in this registry or any parent (for refs). */
+    has(id: string): boolean;
+    /** True only if id is registered on this registry layer (not parent). Used before register. */
+    hasLocal(id: string): boolean;
+}
+/**
+ * Registry that chains lookups to a parent registry (lexical scoping).
+ * Registration/unregistration always happens on the local registry only.
+ */
+declare class ChainedBlockRegistry implements BlockRegistry {
+    private readonly local;
+    private readonly parent;
+    constructor(local: BlockRegistry, parent: BlockRegistry | null);
+    register(id: string, handle: BlockInstanceHandle): void;
+    unregister(id: string): void;
+    get(id: string): BlockInstanceHandle | undefined;
+    has(id: string): boolean;
+    hasLocal(id: string): boolean;
+}
+/**
+ * Default in-memory BlockRegistry.
+ */
+declare class BlockRegistryImpl implements BlockRegistry {
+    private readonly map;
+    register(id: string, handle: BlockInstanceHandle): void;
+    unregister(id: string): void;
+    get(id: string): BlockInstanceHandle | undefined;
+    has(id: string): boolean;
+    hasLocal(id: string): boolean;
+}
+
+interface ScopedRegistryNode {
+    registry: BlockRegistry;
+    parentScopeKey: string | null;
+}
+/**
+ * Holds named block registries (e.g. `root` for a route outlet, scoped keys for list items/columns).
+ * This enables explicit cross-scope ref resolution like `ScopeKey/BlockId:model.title`.
+ */
+declare class BlockRegistryService {
+    readonly registry: Map<string, ScopedRegistryNode>;
+    setScopedRegistry(key: string, reg: BlockRegistry, parentScopeKey?: string | null): void;
+    removeScopedRegistry(key: string): void;
+    getRegistryForScope(scopeKey: string): BlockRegistry | null;
+    getParentScopeKey(scopeKey: string): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BlockRegistryService>;
+}
+
 /**
  * Service entry: root-scoped (string id or { id, alias? } with no scope) or self-scoped ({ id, scope: "self", alias? }).
  * When scope is omitted or undefined, the service is resolved from the root injector.
  */
-declare const ServiceEntrySchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    id: z.ZodString;
-    scope: z.ZodOptional<z.ZodLiteral<"self">>;
-    alias: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>]>;
-/**
- * Output handler: empty (use directive-provided handler) or reference-based (call method on ref).
- */
-declare const OutputReferenceSchema: z.ZodObject<{
-    type: z.ZodLiteral<"reference">;
-    reference: z.ZodString;
-    method: z.ZodString;
-    params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    then: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        reference: z.ZodString;
-        method: z.ZodString;
-        params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    }, z.core.$strip>>>;
-    onSuccess: z.ZodOptional<z.ZodObject<{
-        reference: z.ZodString;
-        method: z.ZodString;
-        params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    }, z.core.$strip>>;
-    onError: z.ZodOptional<z.ZodObject<{
-        reference: z.ZodString;
-        method: z.ZodString;
-        params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+type ServiceEntry = string | {
+    id: string;
+    scope?: 'self';
+    alias?: string;
+};
+/**
+ * After the parent call succeeds, run `then` in order. Each step may nest `then` (runs after that step,
+ * before the next sibling). Step is a callable ref string (`Block:path.method`) or an object with `ref` plus options.
+ */
+type ThenChainStep = string | {
+    ref: string;
+    when?: unknown;
+    params?: unknown[] | Record<string, unknown>;
+    then?: ThenChainStep[];
+};
+interface OutputOnError {
+    ref: string;
+    when?: unknown;
+    params?: unknown[] | Record<string, unknown>;
+}
+/**
+ * Object form when `params`, `when`, `then`, or `onError` are needed. `ref` is a full callable path
+ * (`Block:service.path.method` — last dot segment is the method name).
+ */
+interface OutputCallObject {
+    ref: string;
+    when?: unknown;
+    params?: unknown[] | Record<string, unknown>;
+    then?: ThenChainStep[];
+    onError?: OutputOnError;
+}
+type BlockOutputValue = string | OutputCallObject;
+/** Raw block description input (optional fields may be omitted; defaults applied after validation). */
+interface BlockInput {
+    component: string;
+    id?: string;
+    services?: ServiceEntry | ServiceEntry[];
+    directives?: string | string[];
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, BlockOutputValue>;
+}
 /**
  * Block description: JSON-serializable descriptor for dynamic block loading.
  * Refs in inputs: "model.info.title" (current block) or "BlockID:model.info.title" (block id + service/model + path).
  */
-declare const BlockDescriptionSchema: z.ZodObject<{
-    component: z.ZodString;
-    id: z.ZodOptional<z.ZodString>;
-    services: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        scope: z.ZodOptional<z.ZodLiteral<"self">>;
-        alias: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        scope: z.ZodOptional<z.ZodLiteral<"self">>;
-        alias: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>>]>>>;
-    directives: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodObject<{
-        type: z.ZodLiteral<"reference">;
-        reference: z.ZodString;
-        method: z.ZodString;
-        params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-        then: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            reference: z.ZodString;
-            method: z.ZodString;
-            params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-        }, z.core.$strip>>>;
-        onSuccess: z.ZodOptional<z.ZodObject<{
-            reference: z.ZodString;
-            method: z.ZodString;
-            params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-        }, z.core.$strip>>;
-        onError: z.ZodOptional<z.ZodObject<{
-            reference: z.ZodString;
-            method: z.ZodString;
-            params: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>]>>>;
-}, z.core.$strip>;
-type BlockDescription = z.infer<typeof BlockDescriptionSchema>;
-type BlockInput = z.input<typeof BlockDescriptionSchema>;
-type ServiceEntry = z.infer<typeof ServiceEntrySchema>;
-type OutputReference = z.infer<typeof OutputReferenceSchema>;
+interface BlockDescription {
+    component: string;
+    id?: string;
+    services: ServiceEntry[];
+    directives: string | string[];
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, BlockOutputValue>;
+}
+type SafeParseBlockDescriptionResult = {
+    success: true;
+    data: BlockDescription;
+} | {
+    success: false;
+    error: {
+        message: string;
+    };
+};
+
+declare function safeParseBlockDescription(data: unknown): SafeParseBlockDescriptionResult;
+
+/** @deprecated Use OutputCallObject */
+type OutputReference = OutputCallObject;
 /** Normalize services to array. */
 declare function normalizeServices(services: BlockDescription['services']): ServiceEntry[];
 /** Normalize directives to array of directive ids. */
 declare function normalizeDirectives(directives: BlockDescription['directives']): string[];
-declare function safeParseBlockDescription(data: unknown): ReturnType<typeof BlockDescriptionSchema.safeParse>;
+declare function isOutputCallObject(value: unknown): value is OutputCallObject;
+/** @deprecated Use isOutputCallObject */
 declare function isOutputReference(value: unknown): value is OutputReference;
 /**
  * Reference to a registered block: { blockId: string, blockDefinition?: object }.
@@ -425,44 +493,12 @@ declare function deepMergeBlockDefinition(base: Record<string, unknown>, overrid
  */
 declare function resolveBlockReference(ref: BlockReference, blockDefinitions: Record<string, BlockDefinitionOrLoader> | null | undefined): Promise<Record<string, unknown>>;
 
-interface CurrentInstance {
-    model?: Signal<unknown>;
-    [key: string]: unknown;
-}
-/**
- * Handle for a registered block: exposes instance (services/state by name) for ref resolution.
- */
-interface BlockInstanceHandle {
-    /** Instance: services and state by name (e.g. FormState, value). */
-    instance: CurrentInstance;
-    /** Optional cleanup when block is destroyed. */
-    destroy?: () => void;
-}
-/**
- * Registry of block instances by (full) id within a tree.
- * One registry per logical tree; duplicate id throws.
- */
-interface BlockRegistry {
-    register(id: string, handle: BlockInstanceHandle): void;
-    unregister(id: string): void;
-    get(id: string): BlockInstanceHandle | undefined;
-    has(id: string): boolean;
-}
-/**
- * Default in-memory BlockRegistry.
- */
-declare class BlockRegistryImpl implements BlockRegistry {
-    private readonly map;
-    register(id: string, handle: BlockInstanceHandle): void;
-    unregister(id: string): void;
-    get(id: string): BlockInstanceHandle | undefined;
-    has(id: string): boolean;
-}
-
 /**
  * Parse ref paths and detect {{ref}} (read-only) and [(ref)] (two-way) in strings.
  */
 interface ParsedRefPath {
+    /** Optional scope key prefix for cross-scope refs: `ScopeKey/BlockId:...` */
+    scopeKey?: string;
     blockId?: string;
     serviceOrModel: string;
     pathParts: string[];
@@ -489,6 +525,8 @@ interface ResolverContext {
     currentBlockId?: string;
     /** Current block's instance (services/state by name). */
     currentInstance?: CurrentInstance;
+    /** Optional scope-key → registry lookup for explicit `ScopeKey/BlockId:...` refs. */
+    getRegistryForScope?: (scopeKey: string) => BlockRegistry | null;
 }
 /**
  * Resolve a ref path to the target object and path.
@@ -525,11 +563,98 @@ declare function setRefValue(refPath: string, ctx: ResolverContext, value: unkno
  */
 declare function buildComputedForTemplate(template: string, refPaths: string[], ctx: ResolverContext): Signal<string>;
 
-declare function resolveOutputReference(ref: OutputReference, eventValue: unknown, ctx: ResolverContext): (value: unknown) => void;
-declare function createOutputHandler(outputValue: unknown, outputKey: string, ctx: ResolverContext, directiveHandlers?: Record<string, (value: unknown) => void>): (value: unknown) => void;
+/** AST node types for flow template */
+type FlowNode = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'ref';
+    refPath: string;
+} | {
+    type: 'if';
+    refPath: string;
+    body: FlowNode[];
+    elseBody?: FlowNode[];
+} | {
+    type: 'for';
+    itemVar: string;
+    refPath: string;
+    body: FlowNode[];
+};
+/** Scope for @for (e.g. item, $index) */
+interface FlowScope {
+    [key: string]: unknown;
+}
+interface InterpretFlowOptions {
+    /**
+     * Called for each `text` node (e.g. to expand `{{ }}` inside flow bodies).
+     * Defaults to identity.
+     */
+    interpolateText?: (segment: string) => string;
+    /**
+     * When set, `@if (…)` evaluates this instead of `resolveRefOrModel` (e.g. safe expressions + payload).
+     */
+    resolveCondition?: (expression: string, scope: FlowScope) => unknown;
+    /**
+     * When false, `${…}` values are appended without HTML escaping (e.g. output handler params). Default true.
+     */
+    escapeRefValues?: boolean;
+}
+/**
+ * Parses a flow template string into an AST.
+ * Supports: ${refPath}, @if (refPath) { ... }, @else { ... }, @for (item of refPath) { ... }
+ */
+declare function parseFlowTemplate(template: string): FlowNode[];
+/** Collect all ref paths used in the AST (for reactivity). */
+declare function collectRefPaths(nodes: FlowNode[]): Set<string>;
+/**
+ * Same resolution rules as `interpolateTemplateMixed` for refs: named block ref, else current block `model` path.
+ */
+declare function resolveRefOrModel(refPath: string, ctx: ResolverContext): unknown;
+/**
+ * Interprets the AST with the given resolver context and optional scope (e.g. item, $index).
+ * Escapes interpolated values for safe innerHTML.
+ */
+declare function interpretFlow(nodes: FlowNode[], ctx: ResolverContext, scope?: FlowScope, options?: InterpretFlowOptions): string;
+/** True if the string uses flow syntax (not plain `{{ }}` only). */
+declare function looksLikeFlowTemplate(s: string): boolean;
+
+declare function resolveReferenceValue(ref: string, ctx: ResolverContext): unknown;
+/**
+ * Safe expression evaluation (same as output `{{ }}` / `@if (...)` when used with this module).
+ * Falls back to `resolveReferenceValue` if parsing fails (treat whole string as a ref path).
+ */
+declare function evaluateExpression(expression: string, ctx: ResolverContext, payload: unknown): unknown;
+/**
+ * Resolves only `{{ … }}` segments via `evaluateExpression`.
+ * Single full-string `{{ expr }}` preserves the evaluated type; mixed templates return a string.
+ */
+declare function resolveMustacheInterpolatedString(value: string, ctx: ResolverContext, payload: unknown): unknown;
+declare function mustacheSegmentToString(segment: string, ctx: ResolverContext, payload: unknown): string;
+interface ResolveTemplateStringOptions {
+    /**
+     * When true (default), `${…}` in flow output is HTML-escaped (block / innerHTML-friendly).
+     * Set false for plain strings (e.g. output handler method params).
+     */
+    escapeFlowRefs?: boolean;
+}
+/**
+ * Unified template resolution: flow (`@if`, `@for`, `${}`) plus `{{ }}` in flow text segments.
+ * `@if` conditions use `evaluateExpression` (safe expressions + ref fallback).
+ */
+declare function resolveTemplateString(value: string, ctx: ResolverContext, payload?: unknown, options?: ResolveTemplateStringOptions): unknown;
+
+/**
+ * Split `Block:path.to.method` or `service.path.method` (current block) into ref path + method name.
+ * Last dot-separated segment after `:` is the method; before that is the ref path.
+ */
+declare function splitCallableRef(fullPath: string): {
+    refPath: string;
+    method: string;
+} | null;
+declare function createOutputHandler(outputValue: unknown, _outputKey: string, ctx: ResolverContext): (value: unknown) => void;
 
 interface BlockLoadOptions {
-    outputHandlers?: Record<string, (value: unknown) => void>;
     registry?: BlockRegistry;
     /** Map of block id → full description or loader; used when description is a block reference. */
     blockDefinitions?: Record<string, BlockDefinitionOrLoader>;
@@ -539,6 +664,7 @@ declare class BlockLoaderService {
     private readonly componentRegistry;
     private readonly directiveRegistry;
     private readonly serviceRegistry;
+    private readonly blockRegistryService;
     load(description: BlockInput | BlockReference, viewContainerRef: ViewContainerRef, model: Signal<unknown | undefined>, options?: BlockLoadOptions): Promise<ComponentRef<unknown>>;
     private resolveServices;
     private buildChildInjectorFromTypes;
@@ -548,6 +674,9 @@ declare class BlockLoaderService {
     private getDirectiveTypes;
     /** Resolve model from desc (interpolate ref if string) and set on blockInstance. */
     private resolveContextModel;
+    private valueContainsTemplate;
+    private resolveNestedModelTemplates;
+    private withModelOverrideContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockLoaderService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<BlockLoaderService>;
 }
@@ -557,55 +686,25 @@ declare class BlockDirective {
     private readonly loader;
     private readonly destroyRef;
     /** Full description, or { id } / { blockId, blockDefinition? } to reuse/override from blockDefinitions. */
-    readonly description: _angular_core.InputSignal<{
-        component: string;
-        id?: string | undefined;
-        services?: string | {
-            id: string;
-            scope?: "self" | undefined;
-            alias?: string | undefined;
-        } | (string | {
-            id: string;
-            scope?: "self" | undefined;
-            alias?: string | undefined;
-        })[] | undefined;
-        directives?: string | string[] | undefined;
-        inputs?: Record<string, unknown> | undefined;
-        outputs?: Record<string, Record<string, unknown> | {
-            type: "reference";
-            reference: string;
-            method: string;
-            params?: Record<string, unknown> | unknown[] | undefined;
-            then?: {
-                reference: string;
-                method: string;
-                params?: Record<string, unknown> | unknown[] | undefined;
-            }[] | undefined;
-            onSuccess?: {
-                reference: string;
-                method: string;
-                params?: Record<string, unknown> | unknown[] | undefined;
-            } | undefined;
-            onError?: {
-                reference: string;
-                method: string;
-                params?: Record<string, unknown> | unknown[] | undefined;
-            } | undefined;
-        }> | undefined;
-    } | BlockReference | null>;
-    /** Handlers for component outputs; keys match descriptor.outputs. */
-    readonly outputHandlers: _angular_core.InputSignal<Record<string, (value: unknown) => void>>;
+    readonly description: _angular_core.InputSignal<BlockInput | BlockReference | null>;
     /** Registry for block instances by id; pass from root so nested blocks share it. */
     readonly blockRegistry: _angular_core.InputSignal<BlockRegistry | null>;
     /** Map id → full description or loader; used when description is a block reference (id/blockId). */
     readonly blockDefinitions: _angular_core.InputSignal<Record<string, BlockDefinitionOrLoader> | null>;
     /** Model for the block. */
     readonly model: _angular_core.InputSignal<string | Record<string, unknown> | undefined>;
+    /**
+     * Forces a reload when this value changes, even if component/services are the same.
+     * Useful for "same component, different inputs" scenarios like tabs/switch blocks.
+     */
+    readonly reloadKey: _angular_core.InputSignal<unknown>;
     private loadResult;
     private lastRegistry;
     private lastId;
     private loadedComponent;
     private loadedServicesKey;
+    private loadedReloadKey;
+    private loadedDescKey;
     private loadGeneration;
     /** Invalidates in-flight block-reference resolution when the effect re-runs. */
     private effectRunId;
@@ -615,8 +714,8 @@ declare class BlockDirective {
     constructor();
     private clear;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BlockDirective, "[block]", never, { "description": { "alias": "description"; "required": false; "isSignal": true; }; "outputHandlers": { "alias": "outputHandlers"; "required": false; "isSignal": true; }; "blockRegistry": { "alias": "blockRegistry"; "required": false; "isSignal": true; }; "blockDefinitions": { "alias": "blockDefinitions"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BlockDirective, "[block]", never, { "description": { "alias": "description"; "required": false; "isSignal": true; }; "blockRegistry": { "alias": "blockRegistry"; "required": false; "isSignal": true; }; "blockDefinitions": { "alias": "blockDefinitions"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "reloadKey": { "alias": "reloadKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { BlockDefinitionsRegistry, BlockDescriptionSchema, BlockDirective, BlockLoaderService, BlockRegistryImpl, ComponentRegistry, DirectiveRegistry, GuardRegistry, INTERPOLATE_MAX_PLACEHOLDERS, RegistryMetadataStore, RouteLoader, ServiceRegistry, buildComputedForTemplate, classifyTwoWayString, createOutputHandler, deepMergeBlockDefinition, extractReadonlyRefs, getRefPathFromReadonly, getRefSignal, getRefValue, getValueByPath, isBlockDefinitionLoader, isBlockReference, isInvalidTwoWayMix, isOutputReference, isTwoWayRefString, normalizeDirectives, normalizeServices, parseRefPath, parseTwoWayRef, refPathResolvesToSignal, resolveBlockReference, resolveOutputReference, resolveRefPath, safeParseBlockDescription, setRefValue };
-export type { AllRegistryMetadata, BlockDefinitionLoader, BlockDefinitionOrLoader, BlockDescription, BlockInput, BlockInstanceHandle, BlockLoadOptions, BlockReference, BlockRegistry, CurrentInstance, GuardLoader, GuardOrLoader, GuardOrType, OutputReference, ParsedRefPath, RegistryEntryType, RegistryMetadataRecord, ResolverContext, RouteConfig, ServiceEntry };
+export { BlockDefinitionsRegistry, BlockDirective, BlockLoaderService, BlockRegistryImpl, BlockRegistryService, ChainedBlockRegistry, ComponentRegistry, DirectiveRegistry, GuardRegistry, INTERPOLATE_MAX_PLACEHOLDERS, RegistryMetadataStore, RouteLoader, ServiceRegistry, buildComputedForTemplate, classifyTwoWayString, collectRefPaths, createOutputHandler, deepMergeBlockDefinition, evaluateExpression, extractReadonlyRefs, getRefPathFromReadonly, getRefSignal, getRefValue, getValueByPath, interpretFlow, isBlockDefinitionLoader, isBlockReference, isInvalidTwoWayMix, isOutputCallObject, isOutputReference, isTwoWayRefString, looksLikeFlowTemplate, mustacheSegmentToString, normalizeDirectives, normalizeServices, parseFlowTemplate, parseRefPath, parseTwoWayRef, refPathResolvesToSignal, resolveBlockReference, resolveMustacheInterpolatedString, resolveRefOrModel, resolveRefPath, resolveReferenceValue, resolveTemplateString, safeParseBlockDescription, setRefValue, splitCallableRef };
+export type { AllRegistryMetadata, BlockDefinitionLoader, BlockDefinitionOrLoader, BlockDescription, BlockInput, BlockInstanceHandle, BlockLoadOptions, BlockOutputValue, BlockReference, BlockRegistry, CurrentInstance, FlowNode, FlowScope, GuardLoader, GuardOrLoader, GuardOrType, InterpretFlowOptions, OutputCallObject, OutputOnError, OutputReference, ParsedRefPath, RegistryEntryType, RegistryMetadataRecord, ResolveTemplateStringOptions, ResolverContext, RouteConfig, RouteConfigs, SafeParseBlockDescriptionResult, ScopedRegistryNode, ServiceEntry, ThenChainStep };