ngx-blocks-studio 0.0.15 → 0.1.1

package/fesm2022/ngx-blocks-studio.mjs

@@ -3,7 +3,6 @@ import { inject, signal, computed, Injectable, isSignal, isWritableSignal, linke
 import { Router } from '@angular/router';
 import { HttpClient } from '@angular/common/http';
 import { firstValueFrom } from 'rxjs';
-import { z } from 'zod';
 
 /**
  * Single source of truth for metadata across component, service, and guard registries.
@@ -721,14 +720,17 @@ class RouteLoader {
     http = inject(HttpClient);
     componentRegistry = ComponentRegistry.getInstance();
     guardRegistry = GuardRegistry.getInstance();
-    _routeConfigFile = signal(null, ...(ngDevMode ? [{ debugName: "_routeConfigFile" }] : []));
-    _configPath = signal('', ...(ngDevMode ? [{ debugName: "_configPath" }] : []));
+    _routeConfigFile = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_routeConfigFile" }] : /* istanbul ignore next */ []));
+    _configPath = signal('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_configPath" }] : /* istanbul ignore next */ []));
     /** Currently loaded route config file, or null if not yet loaded. */
     routeConfigFile = this._routeConfigFile.asReadonly();
     /** Path from which the config was loaded. */
     configPath = this._configPath.asReadonly();
     /** Route config array from the loaded file. */
-    routeConfig = computed(() => this._routeConfigFile()?.routes ?? [], ...(ngDevMode ? [{ debugName: "routeConfig" }] : []));
+    routeConfig = computed(() => this._routeConfigFile()?.routes ?? [], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "routeConfig" }] : /* istanbul ignore next */ []));
     /**
      * Load routes from a config object. Updates signals and resets the router.
      */
@@ -849,81 +851,269 @@ class RouteLoader {
         }
         return guard;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: RouteLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: RouteLoader, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: RouteLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: RouteLoader, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: RouteLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: RouteLoader, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
                 }]
         }] });
 
-async function resolveBlockDefinitionValue(raw) {
-    if (isBlockDefinitionLoader(raw)) {
-        return raw();
-    }
-    return raw;
-}
 /**
- * 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.
+ * Registry that chains lookups to a parent registry (lexical scoping).
+ * Registration/unregistration always happens on the local registry only.
  */
-const ServiceEntrySchema = z.union([
-    z.string().min(1),
-    z.object({
-        id: z.string().min(1),
-        scope: z.literal('self').optional(),
-        alias: z.string().min(1).optional(),
-    }),
-]);
+class ChainedBlockRegistry {
+    local;
+    parent;
+    constructor(local, parent) {
+        this.local = local;
+        this.parent = parent;
+    }
+    register(id, handle) {
+        this.local.register(id, handle);
+    }
+    unregister(id) {
+        this.local.unregister(id);
+    }
+    get(id) {
+        return this.local.get(id) ?? this.parent?.get(id);
+    }
+    has(id) {
+        return this.local.has(id) || (this.parent?.has(id) ?? false);
+    }
+    hasLocal(id) {
+        return this.local.hasLocal(id);
+    }
+}
 /**
- * Output handler: empty (use directive-provided handler) or reference-based (call method on ref).
+ * Default in-memory BlockRegistry.
  */
-const OutputReferenceSchema = z.object({
-    type: z.literal('reference'),
-    reference: z.string().min(1),
-    method: z.string().min(1),
-    params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
-    then: z
-        .array(z.object({
-        reference: z.string().min(1),
-        method: z.string().min(1),
-        params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
-    }))
-        .optional(),
-    onSuccess: z
-        .object({
-        reference: z.string().min(1),
-        method: z.string().min(1),
-        params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
-    })
-        .optional(),
-    onError: z
-        .object({
-        reference: z.string().min(1),
-        method: z.string().min(1),
-        params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
-    })
-        .optional(),
-});
-const OutputValueSchema = z.union([z.record(z.string(), z.unknown()), OutputReferenceSchema]);
+class BlockRegistryImpl {
+    map = new Map();
+    register(id, handle) {
+        if (this.map.has(id)) {
+            throw new Error(`Block id "${id}" is already registered. Each id may only occur once per tree.`);
+        }
+        this.map.set(id, handle);
+    }
+    unregister(id) {
+        this.map.delete(id);
+    }
+    get(id) {
+        return this.map.get(id);
+    }
+    has(id) {
+        return this.map.has(id);
+    }
+    hasLocal(id) {
+        return this.map.has(id);
+    }
+}
+
 /**
- * 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).
+ * 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`.
  */
-const BlockDescriptionSchema = z.object({
-    component: z.string().min(1),
-    id: z.string().min(1).optional(),
-    services: z
-        .union([ServiceEntrySchema, z.array(ServiceEntrySchema)])
-        .optional()
-        .default([]),
-    /** Registered directive ids to apply to the host of the dynamically created component. */
-    directives: z.union([z.string().min(1), z.array(z.string().min(1))]).optional().default([]),
-    inputs: z.record(z.string(), z.unknown()).optional(),
-    outputs: z.record(z.string(), OutputValueSchema).optional(),
-});
+class BlockRegistryService {
+    registry = new Map([
+        ['root', { registry: new BlockRegistryImpl(), parentScopeKey: null }],
+    ]);
+    setScopedRegistry(key, reg, parentScopeKey = 'root') {
+        if (key === 'root') {
+            throw new Error('Cannot set scoped registry under reserved key "root".');
+        }
+        this.registry.set(key, { registry: reg, parentScopeKey });
+    }
+    removeScopedRegistry(key) {
+        if (key === 'root')
+            return;
+        this.registry.delete(key);
+    }
+    getRegistryForScope(scopeKey) {
+        return this.registry.get(scopeKey)?.registry ?? null;
+    }
+    getParentScopeKey(scopeKey) {
+        return this.registry.get(scopeKey)?.parentScopeKey ?? null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockRegistryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockRegistryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function isNonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0;
+}
+function validateParams(v, path) {
+    if (v === undefined)
+        return null;
+    if (Array.isArray(v))
+        return null;
+    if (typeof v === 'object' && v !== null && !Array.isArray(v))
+        return null;
+    return `${path}: params must be array or record`;
+}
+function validateServiceEntry(v, path) {
+    if (isNonEmptyString(v))
+        return null;
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return `${path}: invalid service entry`;
+    const o = v;
+    if (!isNonEmptyString(o['id']))
+        return `${path}: service object requires non-empty id`;
+    if (o['scope'] !== undefined && o['scope'] !== 'self')
+        return `${path}: invalid scope`;
+    if (o['alias'] !== undefined && !isNonEmptyString(o['alias']))
+        return `${path}: invalid alias`;
+    return null;
+}
+function validateThenChainStep(v, path) {
+    if (isNonEmptyString(v))
+        return null;
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return `${path}: invalid then step`;
+    const o = v;
+    if (!isNonEmptyString(o['ref']))
+        return `${path}: then step object requires ref`;
+    const p = validateParams(o['params'], `${path}.params`);
+    if (p)
+        return p;
+    if (o['then'] !== undefined) {
+        if (!Array.isArray(o['then']))
+            return `${path}.then must be an array`;
+        for (let i = 0; i < o['then'].length; i++) {
+            const e = validateThenChainStep(o['then'][i], `${path}.then[${i}]`);
+            if (e)
+                return e;
+        }
+    }
+    return null;
+}
+function validateOnError(v, path) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return `${path}: invalid onError`;
+    const o = v;
+    if (!isNonEmptyString(o['ref']))
+        return `${path}: onError requires ref`;
+    return validateParams(o['params'], `${path}.params`);
+}
+function validateOutputCallObject(v, path) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return `${path}: invalid output object`;
+    const o = v;
+    if (!isNonEmptyString(o['ref']))
+        return `${path}: output object requires ref`;
+    const p = validateParams(o['params'], `${path}.params`);
+    if (p)
+        return p;
+    if (o['then'] !== undefined) {
+        if (!Array.isArray(o['then']))
+            return `${path}.then must be an array`;
+        for (let i = 0; i < o['then'].length; i++) {
+            const e = validateThenChainStep(o['then'][i], `${path}.then[${i}]`);
+            if (e)
+                return e;
+        }
+    }
+    if (o['onError'] !== undefined) {
+        const e = validateOnError(o['onError'], `${path}.onError`);
+        if (e)
+            return e;
+    }
+    return null;
+}
+function validateOutputValue(v, path) {
+    if (isNonEmptyString(v))
+        return null;
+    return validateOutputCallObject(v, path);
+}
+function validateBlockDescriptionShape(data) {
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+        return 'Expected an object';
+    }
+    const o = data;
+    if (!isNonEmptyString(o['component']))
+        return 'component is required and must be non-empty';
+    if (o['id'] !== undefined && !isNonEmptyString(o['id']))
+        return 'id must be a non-empty string';
+    if (o['services'] !== undefined && o['services'] !== null) {
+        const s = o['services'];
+        const entries = Array.isArray(s) ? s : [s];
+        for (let i = 0; i < entries.length; i++) {
+            const e = validateServiceEntry(entries[i], `services[${i}]`);
+            if (e)
+                return e;
+        }
+    }
+    if (o['directives'] !== undefined && o['directives'] !== null) {
+        const d = o['directives'];
+        if (isNonEmptyString(d)) {
+            /* ok */
+        }
+        else if (Array.isArray(d)) {
+            for (let i = 0; i < d.length; i++) {
+                if (!isNonEmptyString(d[i]))
+                    return `directives[${i}] must be a non-empty string`;
+            }
+        }
+        else {
+            return 'directives must be a string or array of strings';
+        }
+    }
+    if (o['inputs'] !== undefined && o['inputs'] !== null) {
+        if (typeof o['inputs'] !== 'object' || Array.isArray(o['inputs']))
+            return 'inputs must be an object';
+    }
+    if (o['outputs'] !== undefined && o['outputs'] !== null) {
+        if (typeof o['outputs'] !== 'object' || Array.isArray(o['outputs']))
+            return 'outputs must be an object';
+        const outs = o['outputs'];
+        for (const key of Object.keys(outs)) {
+            const e = validateOutputValue(outs[key], `outputs.${key}`);
+            if (e)
+                return e;
+        }
+    }
+    return null;
+}
+function safeParseBlockDescription(data) {
+    const message = validateBlockDescriptionShape(data);
+    if (message)
+        return { success: false, error: { message } };
+    const o = data;
+    const servicesRaw = o['services'];
+    const services = servicesRaw == null
+        ? []
+        : Array.isArray(servicesRaw)
+            ? servicesRaw
+            : [servicesRaw];
+    const directivesRaw = o['directives'];
+    const directives = directivesRaw == null ? [] : directivesRaw;
+    const result = {
+        component: o['component'],
+        services,
+        directives,
+    };
+    if (o['id'] !== undefined)
+        result.id = o['id'];
+    if (o['inputs'] !== undefined)
+        result.inputs = o['inputs'];
+    if (o['outputs'] !== undefined)
+        result.outputs = o['outputs'];
+    return { success: true, data: result };
+}
+
+async function resolveBlockDefinitionValue(raw) {
+    if (isBlockDefinitionLoader(raw)) {
+        return raw();
+    }
+    return raw;
+}
 /** Normalize services to array. */
 function normalizeServices(services) {
     if (services == null)
@@ -936,15 +1126,16 @@ function normalizeDirectives(directives) {
         return [];
     return Array.isArray(directives) ? directives : [directives];
 }
-function safeParseBlockDescription(data) {
-    return BlockDescriptionSchema.safeParse(data);
-}
-function isOutputReference(value) {
+function isOutputCallObject(value) {
     return (typeof value === 'object' &&
         value !== null &&
-        value.type === 'reference' &&
-        typeof value.reference === 'string' &&
-        typeof value.method === 'string');
+        !Array.isArray(value) &&
+        typeof value.ref === 'string' &&
+        value.ref.length > 0);
+}
+/** @deprecated Use isOutputCallObject */
+function isOutputReference(value) {
+    return isOutputCallObject(value);
 }
 function isBlockReference(value) {
     if (typeof value !== 'object' || value === null || 'component' in value)
@@ -1010,28 +1201,6 @@ async function resolveBlockReference(ref, blockDefinitions) {
     return deepMergeBlockDefinition(base, overrides);
 }
 
-/**
- * Default in-memory BlockRegistry.
- */
-class BlockRegistryImpl {
-    map = new Map();
-    register(id, handle) {
-        if (this.map.has(id)) {
-            throw new Error(`Block id "${id}" is already registered. Each id may only occur once per tree.`);
-        }
-        this.map.set(id, handle);
-    }
-    unregister(id) {
-        this.map.delete(id);
-    }
-    get(id) {
-        return this.map.get(id);
-    }
-    has(id) {
-        return this.map.has(id);
-    }
-}
-
 /**
  * Parse ref paths and detect {{ref}} (read-only) and [(ref)] (two-way) in strings.
  */
@@ -1051,10 +1220,17 @@ function parseRefPathUncached(refPath) {
     if (colonIndex !== -1) {
         const prefix = trimmed.slice(0, colonIndex).trim();
         const rest = trimmed.slice(colonIndex + 1).trim();
+        // Prefix may be "BlockID" or "ScopeKey/BlockID" (scope key may contain '/').
         // BlockID must not contain a dot (so "BlockID:model.info.title" is valid; "a:b:c" → prefix "a", rest "b:c")
         if (prefix.length > 0 && !prefix.includes('.')) {
+            const lastSlash = prefix.lastIndexOf('/');
+            const scopeKey = lastSlash !== -1 ? prefix.slice(0, lastSlash) : undefined;
+            const blockId = lastSlash !== -1 ? prefix.slice(lastSlash + 1) : prefix;
+            if (!blockId) {
+                throw new Error(`Invalid block id: ${prefix}`);
+            }
             const pathParts = rest.split('.').filter(Boolean);
-            return { blockId: prefix, serviceOrModel: pathParts[0], pathParts: pathParts.slice(1) };
+            return { scopeKey, blockId, serviceOrModel: pathParts[0], pathParts: pathParts.slice(1) };
         }
         else {
             throw new Error(`Invalid block id: ${prefix}`);
@@ -1115,9 +1291,18 @@ function classifyTwoWayString(value) {
     if (typeof value !== 'string')
         return 'none';
     const s = value.trim();
-    if (!s.includes('[(') && !s.includes(')]'))
+    if (TWOWAY_REF_RE.test(s))
+        return 'two-way';
+    const hasOpen = s.includes('[(');
+    const hasClose = s.includes(')]');
+    if (!hasOpen && !hasClose)
         return 'none';
-    return TWOWAY_REF_RE.test(s) ? 'two-way' : 'invalid-mix';
+    // Only treat as invalid mix when the string looks like an attempted two-way ref
+    // wrapper, not when it contains ")]" from normal indexing/calls inside templates.
+    if ((hasOpen && hasClose) || s.startsWith('[(') || s.endsWith(')]')) {
+        return 'invalid-mix';
+    }
+    return 'none';
 }
 function parseTwoWayRef(value) {
     const m = value.trim().match(TWOWAY_REF_RE);
@@ -1132,6 +1317,16 @@ function escapeRe(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+const WARN_CACHE_MAX = 200;
+const warnCache = new Set();
+function warnOnce(msg) {
+    if (warnCache.has(msg))
+        return;
+    if (warnCache.size >= WARN_CACHE_MAX)
+        warnCache.clear();
+    warnCache.add(msg);
+    console.warn(msg);
+}
 /**
  * Resolve a ref path to the target object and path.
  * Path format: "model.info.title" (current block) or "BlockID:model.info.title" (named block).
@@ -1140,30 +1335,77 @@ function escapeRe(s) {
  */
 function resolveRefPath(refPath, ctx) {
     const parsed = parseRefPath(refPath);
-    const { blockId, serviceOrModel, pathParts } = parsed;
+    const { scopeKey, blockId, serviceOrModel, pathParts } = parsed;
     if (!serviceOrModel) {
         return null;
     }
+    const registry = scopeKey != null
+        ? (ctx.getRegistryForScope?.(scopeKey) ?? null)
+        : ctx.registry;
+    if (scopeKey != null && registry == null) {
+        warnOnce(`Ref "${refPath}" could not resolve scope "${scopeKey}".`);
+        return null;
+    }
     let instance;
     if (blockId != null) {
-        const handle = ctx.registry.get(blockId);
-        if (!handle)
-            return null;
-        instance = handle.instance;
+        // Allow self-references during load before the current block is registered.
+        // Important: only shortcut when there is no explicit scope. Scoped refs must resolve through that scope's registry.
+        if (scopeKey == null &&
+            ctx.currentBlockId != null &&
+            blockId === ctx.currentBlockId &&
+            ctx.currentInstance != null) {
+            instance = ctx.currentInstance;
+        }
+        else {
+            const handle = (registry ?? ctx.registry).get(blockId);
+            if (!handle) {
+                warnOnce(`Ref "${refPath}" could not resolve block id "${blockId}".`);
+                return null;
+            }
+            instance = handle.instance;
+        }
     }
     else {
         instance = ctx.currentInstance ?? undefined;
     }
     if (instance == null)
         return null;
-    const service = instance[serviceOrModel];
-    if (!service)
+    // Special-case: `model` refers to the instance model signal (not a service).
+    if (serviceOrModel === 'model') {
+        const base = instance.model;
+        if (!base) {
+            warnOnce(`Ref "${refPath}" could not resolve model (no instance model).`);
+            return null;
+        }
+        if (pathParts.length === 0) {
+            return { target: base, path: [] };
+        }
+        let current = base;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            if (current != null && isSignal(current)) {
+                current = current();
+            }
+            if (current == null || typeof current !== 'object')
+                return null;
+            current = current[pathParts[i]];
+        }
+        return { target: current, path: pathParts.slice(-1) };
+    }
+    const service = instance.services?.[serviceOrModel];
+    // If the named service/model is not present on the instance, fall back to `model.<serviceOrModel>...`
+    // (e.g. `Kanban:title` -> `Kanban.model.title`) but only for named-block refs.
+    const shouldModelFallback = blockId != null && service == null && instance.model != null;
+    const base = shouldModelFallback ? instance.model : service;
+    const effectiveParts = shouldModelFallback ? [serviceOrModel, ...pathParts] : pathParts;
+    if (!base) {
+        warnOnce(`Ref "${refPath}" could not resolve service/model "${serviceOrModel}".`);
         return null;
-    if (pathParts.length === 0) {
-        return { target: service, path: [] };
     }
-    let current = service;
-    for (let i = 0; i < pathParts.length - 1; i++) {
+    if (effectiveParts.length === 0) {
+        return { target: base, path: [] };
+    }
+    let current = base;
+    for (let i = 0; i < effectiveParts.length - 1; i++) {
         // Unwrap signals at each segment so model.item.a works even when
         // model or item are signals.
         if (current != null && isSignal(current)) {
@@ -1171,11 +1413,11 @@ function resolveRefPath(refPath, ctx) {
         }
         if (current == null || typeof current !== 'object')
             return null;
-        current = current[pathParts[i]];
+        current = current[effectiveParts[i]];
     }
     // Do not unwrap the final segment here; leave it to getRefValue / setRefValue so they
     // can consistently handle signals and functions at the leaf.
-    return { target: current, path: pathParts.slice(-1) };
+    return { target: current, path: effectiveParts.slice(-1) };
 }
 /**
  * Get a value from an object by dot-notation path (e.g. "name.firstName" -> obj.name?.firstName).
@@ -1234,13 +1476,23 @@ function getRefSignal(refPath, ctx) {
     const resolved = resolveRefPath(refPath, ctx);
     if (resolved == null)
         return undefined;
-    const val = resolved.path.length === 0
-        ? resolved.target
-        : resolved.target?.[resolved.path[0]];
-    if (val != null && isSignal(val)) {
-        return val;
+    let value;
+    if (resolved.path.length === 0) {
+        value = resolved.target;
+    }
+    else {
+        if (isSignal(resolved.target)) {
+            const signalValue = resolved.target();
+            value =
+                signalValue != null && typeof signalValue === 'object'
+                    ? signalValue[resolved.path[0]]
+                    : undefined;
+        }
+        else {
+            value = resolved.target?.[resolved.path[0]];
+        }
     }
-    return undefined;
+    return value != null && isSignal(value) ? value : undefined;
 }
 /**
  * Set value at ref path (write). No-op if target is not writable.
@@ -1278,6 +1530,284 @@ function buildComputedForTemplate(template, refPaths, ctx) {
     });
 }
 
+/** Match ${refPath} at start of string (no g flag so match() returns groups). */
+const REF_AT_START_RE = /^\$\{([^}]*)\}/;
+const IF_PREFIX_RE = /^@if\s*\(/;
+const FOR_PREFIX_RE = /^@for\s*\(/;
+/** `s[openIdx] === '('` → index of matching `)`, or -1. */
+function findMatchingParen(s, openIdx) {
+    let depth = 0;
+    for (let k = openIdx; k < s.length; k++) {
+        const c = s[k];
+        if (c === '(')
+            depth++;
+        else if (c === ')') {
+            depth--;
+            if (depth === 0)
+                return k;
+        }
+    }
+    return -1;
+}
+function findMatchingBrace(s, start) {
+    let depth = 1;
+    for (let i = start; i < s.length; i++) {
+        if (s[i] === '{')
+            depth++;
+        else if (s[i] === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Parses a flow template string into an AST.
+ * Supports: ${refPath}, @if (refPath) { ... }, @else { ... }, @for (item of refPath) { ... }
+ */
+function parseFlowTemplate(template) {
+    const nodes = [];
+    let i = 0;
+    while (i < template.length) {
+        const rest = template.slice(i);
+        const ifPrefix = rest.match(IF_PREFIX_RE);
+        if (ifPrefix) {
+            const openParenIdx = i + ifPrefix[0].length - 1;
+            const closeParenIdx = findMatchingParen(template, openParenIdx);
+            if (closeParenIdx === -1) {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const refPath = template.slice(openParenIdx + 1, closeParenIdx).trim();
+            let bodyOpen = closeParenIdx + 1;
+            while (bodyOpen < template.length && /\s/.test(template[bodyOpen]))
+                bodyOpen++;
+            if (template[bodyOpen] !== '{') {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const bodyStart = bodyOpen + 1;
+            const bodyEnd = findMatchingBrace(template, bodyStart);
+            if (bodyEnd === -1) {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const body = template.slice(bodyStart, bodyEnd);
+            let next = bodyEnd + 1;
+            let elseBody;
+            let cursor = next;
+            while (cursor < template.length && /\s/.test(template[cursor] ?? '')) {
+                cursor++;
+            }
+            if (template.startsWith('@else', cursor)) {
+                let elseCursor = cursor + '@else'.length;
+                while (elseCursor < template.length && /\s/.test(template[elseCursor] ?? '')) {
+                    elseCursor++;
+                }
+                if (template[elseCursor] === '{') {
+                    const elseEnd = findMatchingBrace(template, elseCursor + 1);
+                    if (elseEnd !== -1) {
+                        elseBody = parseFlowTemplate(template.slice(elseCursor + 1, elseEnd));
+                        next = elseEnd + 1;
+                    }
+                }
+            }
+            nodes.push({ type: 'if', refPath, body: parseFlowTemplate(body), elseBody });
+            i = next;
+            continue;
+        }
+        const forPrefix = rest.match(FOR_PREFIX_RE);
+        if (forPrefix) {
+            const openParenIdx = i + forPrefix[0].length - 1;
+            const closeParenIdx = findMatchingParen(template, openParenIdx);
+            if (closeParenIdx === -1) {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const inner = template.slice(openParenIdx + 1, closeParenIdx).trim();
+            const ofMatch = inner.match(/^(\w+)\s+of\s+([\s\S]+)$/);
+            if (!ofMatch) {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const itemVar = ofMatch[1];
+            const refPath = ofMatch[2].trim();
+            let bodyOpen = closeParenIdx + 1;
+            while (bodyOpen < template.length && /\s/.test(template[bodyOpen]))
+                bodyOpen++;
+            if (template[bodyOpen] !== '{') {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const bodyStart = bodyOpen + 1;
+            const bodyEnd = findMatchingBrace(template, bodyStart);
+            if (bodyEnd === -1) {
+                nodes.push({ type: 'text', value: rest });
+                break;
+            }
+            const body = template.slice(bodyStart, bodyEnd);
+            nodes.push({ type: 'for', itemVar, refPath, body: parseFlowTemplate(body) });
+            i = bodyEnd + 1;
+            continue;
+        }
+        const refMatch = rest.match(REF_AT_START_RE);
+        if (refMatch) {
+            const refPath = refMatch[1].trim();
+            nodes.push({ type: 'ref', refPath });
+            i += refMatch[0].length;
+            continue;
+        }
+        const nextAt = rest.search(/@(?:if|else|for)\s/);
+        const nextDollar = rest.indexOf('${');
+        let end;
+        if (nextAt >= 0 && (nextDollar < 0 || nextAt < nextDollar))
+            end = i + nextAt;
+        else if (nextDollar >= 0)
+            end = i + nextDollar;
+        else
+            end = template.length;
+        if (end > i) {
+            nodes.push({ type: 'text', value: template.slice(i, end) });
+            i = end;
+        }
+        else {
+            nodes.push({ type: 'text', value: rest[0] ?? '' });
+            i++;
+        }
+    }
+    return nodes;
+}
+/** Collect all ref paths used in the AST (for reactivity). */
+function collectRefPaths(nodes) {
+    const paths = new Set();
+    function walk(ns) {
+        for (const n of ns) {
+            if (n.type === 'ref')
+                paths.add(n.refPath);
+            else if (n.type === 'if') {
+                paths.add(n.refPath);
+                walk(n.body);
+                if (n.elseBody)
+                    walk(n.elseBody);
+            }
+            else if (n.type === 'for') {
+                paths.add(n.refPath);
+                walk(n.body);
+            }
+        }
+    }
+    walk(nodes);
+    return paths;
+}
+function escapeHtml(s) {
+    const el = typeof document !== 'undefined' ? document.createElement('div') : null;
+    if (el) {
+        el.textContent = s;
+        return el.innerHTML;
+    }
+    return s
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function resolveInScope(refPath, scope) {
+    const parts = refPath.trim().split('.');
+    let v = scope[parts[0]];
+    for (let i = 1; i < parts.length && v !== undefined && v !== null; i++) {
+        v = v[parts[i]];
+    }
+    return v;
+}
+function isTruthyFlowValue(value) {
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (!normalized)
+            return false;
+        if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
+            return false;
+        }
+        return true;
+    }
+    return !!value;
+}
+/**
+ * Same resolution rules as `interpolateTemplateMixed` for refs: named block ref, else current block `model` path.
+ */
+function resolveRefOrModel(refPath, ctx) {
+    const ref = refPath.trim();
+    if (!ref)
+        return undefined;
+    const resolved = resolveRefPath(ref, ctx);
+    if (resolved != null) {
+        return getRefValue(ref, ctx);
+    }
+    return getValueByPath(ctx.currentInstance?.model?.() ?? {}, ref);
+}
+/**
+ * Interprets the AST with the given resolver context and optional scope (e.g. item, $index).
+ * Escapes interpolated values for safe innerHTML.
+ */
+function interpretFlow(nodes, ctx, scope = {}, options) {
+    const interpText = options?.interpolateText ?? ((s) => s);
+    const escapeRefs = options?.escapeRefValues !== false;
+    let out = '';
+    for (const node of nodes) {
+        if (node.type === 'text') {
+            out += interpText(node.value);
+            continue;
+        }
+        if (node.type === 'ref') {
+            const refPath = node.refPath.trim();
+            const firstSegment = refPath.split('.')[0];
+            let value;
+            if (firstSegment && firstSegment in scope) {
+                value = resolveInScope(refPath, scope);
+            }
+            else {
+                value = resolveRefOrModel(refPath, ctx);
+            }
+            if (value !== undefined && value !== null) {
+                const chunk = String(value);
+                out += escapeRefs ? escapeHtml(chunk) : chunk;
+            }
+            continue;
+        }
+        if (node.type === 'if') {
+            const rawExpr = node.refPath.trim();
+            const cond = options?.resolveCondition
+                ? options.resolveCondition(rawExpr, scope)
+                : resolveRefOrModel(rawExpr, ctx);
+            if (isTruthyFlowValue(cond)) {
+                out += interpretFlow(node.body, ctx, scope, options);
+            }
+            else if (node.elseBody?.length) {
+                out += interpretFlow(node.elseBody, ctx, scope, options);
+            }
+            continue;
+        }
+        if (node.type === 'for') {
+            const arr = resolveRefOrModel(node.refPath, ctx);
+            const list = Array.isArray(arr) ? arr : [];
+            for (let idx = 0; idx < list.length; idx++) {
+                out += interpretFlow(node.body, ctx, {
+                    ...scope,
+                    [node.itemVar]: list[idx],
+                    $index: idx,
+                }, options);
+            }
+            continue;
+        }
+    }
+    return out;
+}
+/** True if the string uses flow syntax (not plain `{{ }}` only). */
+function looksLikeFlowTemplate(s) {
+    return /@(?:if|for)\s*\(/.test(s) || /\$\{[^}]+\}/.test(s);
+}
+
 function isIdentStart(ch) {
     return /[A-Za-z_$]/.test(ch);
 }
@@ -1303,6 +1833,16 @@ function tokenize(input) {
             i++;
             continue;
         }
+        if (ch === '[') {
+            tokens.push({ type: 'lbracket', value: ch });
+            i++;
+            continue;
+        }
+        if (ch === ']') {
+            tokens.push({ type: 'rbracket', value: ch });
+            i++;
+            continue;
+        }
         if (ch === '.') {
             tokens.push({ type: 'dot', value: ch });
             i++;
@@ -1483,6 +2023,13 @@ class Parser {
                 expr = { kind: 'member', object: expr, property: id.value };
                 continue;
             }
+            if (this.peek().type === 'lbracket') {
+                this.next();
+                const index = this.parseConditional();
+                this.expect('rbracket');
+                expr = { kind: 'index', object: expr, index };
+                continue;
+            }
             if (this.peek().type === 'lparen') {
                 this.next();
                 const args = [];
@@ -1530,25 +2077,55 @@ function evalExpr(expr, ctx) {
             }
             if (expr.name in ctx.model)
                 return ctx.model[expr.name];
-            if (ctx.currentInstance != null && expr.name in ctx.currentInstance)
-                return ctx.currentInstance[expr.name];
+            if (ctx.services != null && expr.name in ctx.services)
+                return ctx.services[expr.name];
             return undefined;
         case 'member': {
-            const obj = evalExpr(expr.object, ctx);
+            let obj = evalExpr(expr.object, ctx);
+            // Support expressions like ref("Block:model").title where ref(...) can return a signal/function.
+            if (expr.object.kind === 'call' &&
+                expr.object.callee.kind === 'identifier' &&
+                expr.object.callee.name === 'ref' &&
+                typeof obj === 'function') {
+                obj = obj();
+            }
             if (obj == null || typeof obj !== 'object')
                 return undefined;
             return obj[expr.property];
         }
+        case 'index': {
+            let obj = evalExpr(expr.object, ctx);
+            if (expr.object.kind === 'call' &&
+                expr.object.callee.kind === 'identifier' &&
+                expr.object.callee.name === 'ref' &&
+                typeof obj === 'function') {
+                obj = obj();
+            }
+            if (obj == null || (typeof obj !== 'object' && typeof obj !== 'function'))
+                return undefined;
+            const key = evalExpr(expr.index, ctx);
+            if (typeof key !== 'string' && typeof key !== 'number')
+                return undefined;
+            return obj[key];
+        }
         case 'call': {
             if (expr.callee.kind !== 'identifier' || expr.callee.name !== 'ref') {
                 throw new Error('Only ref(...) calls are allowed');
             }
-            if (expr.args.length !== 1)
-                throw new Error('ref(...) requires one argument');
+            if (expr.args.length < 1 || expr.args.length > 2) {
+                throw new Error('ref(...) requires one or two arguments');
+            }
             const arg = evalExpr(expr.args[0], ctx);
             if (typeof arg !== 'string')
                 return undefined;
-            return ctx.resolveRefValue(arg);
+            const resolved = ctx.resolveRefValue(arg);
+            const shouldInvoke = expr.args.length === 2
+                ? evalExpr(expr.args[1], ctx) === true
+                : false;
+            if (shouldInvoke && typeof resolved === 'function') {
+                return resolved();
+            }
+            return resolved;
         }
         case 'unary': {
             const v = evalExpr(expr.argument, ctx);
@@ -1593,33 +2170,22 @@ function evaluateSafeExpression(expression, resolverContext, payload, resolveRef
     return evalExpr(ast, {
         payload,
         model: (resolverContext.currentInstance?.model?.() ?? {}),
-        currentInstance: resolverContext.currentInstance,
+        services: resolverContext.currentInstance?.services,
         resolveRefValue: (ref) => resolveRefValue(ref, resolverContext),
     });
 }
 
-function getCallTarget(reference, ctx) {
-    const resolved = resolveRefPath(reference, ctx);
-    if (resolved == null)
-        return undefined;
-    const { target, path } = resolved;
-    if (path.length === 0)
-        return target;
-    const parent = target;
-    return parent?.[path[0]];
-}
-function getMethodOnTarget(target, methodName) {
-    if (target == null)
-        return null;
-    const m = target[methodName];
-    return typeof m === 'function' ? m : null;
-}
+const MUSTACHE_MAX_SEGMENTS = 200;
 function resolveReferenceValue(ref, ctx) {
     const resolved = resolveRefPath(ref, ctx);
     if (resolved != null)
         return getRefValue(ref, ctx);
     return getValueByPath(ctx.currentInstance?.model?.() ?? {}, ref);
 }
+/**
+ * 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).
+ */
 function evaluateExpression(expression, ctx, payload) {
     const trimmed = expression.trim();
     if (!trimmed)
@@ -1631,20 +2197,29 @@ function evaluateExpression(expression, ctx, payload) {
         return resolveReferenceValue(trimmed, ctx);
     }
 }
-function resolveInterpolatedString(value, ctx, payload) {
+/**
+ * Resolves only `{{ … }}` segments via `evaluateExpression`.
+ * Single full-string `{{ expr }}` preserves the evaluated type; mixed templates return a string.
+ */
+function resolveMustacheInterpolatedString(value, ctx, payload) {
     if (!value.includes('{{') || !value.includes('}}'))
         return value;
     const re = /\{\{([\s\S]*?)\}\}/g;
     const matches = [...value.matchAll(re)];
     if (matches.length === 0)
         return value;
-    // If the whole string is a single interpolation, preserve the original type.
-    if (matches.length === 1 && matches[0][0].length === value.trim().length && matches[0][0] === value.trim()) {
-        return evaluateExpression(matches[0][1], ctx, payload);
+    if (matches.length > MUSTACHE_MAX_SEGMENTS) {
+        console.warn(`Template has more than ${MUSTACHE_MAX_SEGMENTS} mustache segments; truncating interpolation.`);
+    }
+    const limited = matches.slice(0, MUSTACHE_MAX_SEGMENTS);
+    if (limited.length === 1 &&
+        limited[0][0].length === value.trim().length &&
+        limited[0][0] === value.trim()) {
+        return evaluateExpression(limited[0][1], ctx, payload);
     }
     let out = '';
     let lastIndex = 0;
-    for (const match of matches) {
+    for (const match of limited) {
         const start = match.index ?? 0;
         out += value.slice(lastIndex, start);
         const evaluated = evaluateExpression(match[1], ctx, payload);
@@ -1654,14 +2229,91 @@ function resolveInterpolatedString(value, ctx, payload) {
     out += value.slice(lastIndex);
     return out;
 }
+function mustacheSegmentToString(segment, ctx, payload) {
+    const v = resolveMustacheInterpolatedString(segment, ctx, payload);
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v;
+    return String(v);
+}
+/**
+ * Unified template resolution: flow (`@if`, `@for`, `${}`) plus `{{ }}` in flow text segments.
+ * `@if` conditions use `evaluateExpression` (safe expressions + ref fallback).
+ */
+function resolveTemplateString(value, ctx, payload = undefined, options) {
+    const escapeFlowRefs = options?.escapeFlowRefs !== false;
+    if (looksLikeFlowTemplate(value)) {
+        return interpretFlow(parseFlowTemplate(value), ctx, {}, {
+            escapeRefValues: escapeFlowRefs,
+            resolveCondition: (expr) => evaluateExpression(expr, ctx, payload),
+            interpolateText: (segment) => mustacheSegmentToString(segment, ctx, payload),
+        });
+    }
+    return resolveMustacheInterpolatedString(value, ctx, payload);
+}
+
+function getCallTarget(reference, ctx) {
+    const resolved = resolveRefPath(reference, ctx);
+    if (resolved == null)
+        return undefined;
+    const { target, path } = resolved;
+    if (path.length === 0)
+        return target;
+    const parent = target;
+    return parent?.[path[0]];
+}
+function resolveReferencePath(reference, ctx, payload) {
+    const resolved = resolveTemplateString(reference, ctx, payload, { escapeFlowRefs: false });
+    return typeof resolved === 'string' ? resolved : String(resolved ?? '');
+}
+/**
+ * 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.
+ */
+function splitCallableRef(fullPath) {
+    const trimmed = fullPath.trim();
+    if (!trimmed)
+        return null;
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx !== -1) {
+        const prefix = trimmed.slice(0, colonIdx).trim();
+        const rest = trimmed.slice(colonIdx + 1).trim();
+        const parts = rest.split('.').filter(Boolean);
+        if (parts.length < 2)
+            return null;
+        const method = parts[parts.length - 1];
+        const parentRest = parts.slice(0, -1).join('.');
+        return { refPath: `${prefix}:${parentRest}`, method };
+    }
+    const parts = trimmed.split('.').filter(Boolean);
+    if (parts.length < 2)
+        return null;
+    const method = parts[parts.length - 1];
+    const refPath = parts.slice(0, -1).join('.');
+    return { refPath, method };
+}
+function getMethodOnTarget(target, methodName) {
+    if (target == null)
+        return null;
+    const m = target[methodName];
+    return typeof m === 'function' ? m : null;
+}
+function warnNotCallable(resolvedFullRef, refPath, method, callTarget) {
+    const leafDesc = callTarget != null && typeof callTarget === 'object'
+        ? typeof callTarget[method]
+        : 'n/a';
+    console.warn(`Output call "${resolvedFullRef}": "${method}" is not a callable function ` +
+        `(ref path "${refPath}"); resolved leaf type: ${leafDesc}.`);
+}
 function resolveOutputParamValue(value, ctx, payload) {
     if (typeof value === 'string') {
-        return resolveInterpolatedString(value, ctx, payload);
+        return resolveTemplateString(value, ctx, payload, { escapeFlowRefs: false });
     }
     if (Array.isArray(value)) {
         return value.map((item) => resolveOutputParamValue(item, ctx, payload));
     }
-    if (value != null && typeof value === 'object') {
+    if (value != null && typeof value === 'object' && !('component' in value)) {
         return Object.fromEntries(Object.entries(value).map(([key, item]) => [
             key,
             resolveOutputParamValue(item, ctx, payload),
@@ -1669,59 +2321,141 @@ function resolveOutputParamValue(value, ctx, payload) {
     }
     return value;
 }
-function resolveOutputReference(ref, eventValue, ctx) {
+function isTruthyOutputCondition(value) {
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (!normalized)
+            return false;
+        if (normalized === 'false' || normalized === '0' || normalized === 'no' || normalized === 'off') {
+            return false;
+        }
+        return true;
+    }
+    return !!value;
+}
+function shouldRunWhen(when, ctx, payload) {
+    if (when == null)
+        return true;
+    const resolved = resolveOutputParamValue(when, ctx, payload);
+    return isTruthyOutputCondition(resolved);
+}
+function buildOutputHandlerFromCall(refTemplate, extras, ctx, eventValue) {
+    const def = { ref: refTemplate, ...extras };
     return (value) => {
         const payload = value ?? eventValue;
-        const callTarget = getCallTarget(ref.reference, ctx);
-        const method = getMethodOnTarget(callTarget, ref.method);
-        if (method == null) {
-            console.warn(`Output reference ${ref.reference} has no method ${ref.method}`);
+        if (!shouldRunWhen(def.when, ctx, payload)) {
             return;
         }
-        const params = ref.params != null
-            ? (Array.isArray(ref.params) ? ref.params : [ref.params]).map((param) => resolveOutputParamValue(param, ctx, payload))
+        const resolvedCallable = resolveReferencePath(refTemplate, ctx, payload);
+        const split = splitCallableRef(resolvedCallable);
+        if (split == null) {
+            console.warn(`Invalid output callable ref "${resolvedCallable}" (expected e.g. Block:path.method or service.path.method)`);
+            return;
+        }
+        const { refPath, method } = split;
+        const callTarget = getCallTarget(refPath, ctx);
+        const fn = getMethodOnTarget(callTarget, method);
+        if (fn == null) {
+            warnNotCallable(resolvedCallable, refPath, method, callTarget);
+            return;
+        }
+        const params = def.params != null
+            ? (Array.isArray(def.params) ? def.params : [def.params]).map((param) => resolveOutputParamValue(param, ctx, payload))
             : [payload];
-        const result = method.call(callTarget, ...params);
+        const result = fn.call(callTarget, ...params);
         if (result != null && typeof result.then === 'function') {
-            result.then(() => runThenOrSuccess(ref, ctx), () => runOnError(ref, ctx));
+            result.then(() => runThenOrSuccess(def, ctx, payload), () => runOnError(def, ctx, payload));
         }
         else {
-            runThenOrSuccess(ref, ctx);
+            runThenOrSuccess(def, ctx, payload);
         }
     };
 }
-function toParams(p) {
+function resolveStepParams(p, ctx, payload) {
     if (p == null)
         return [];
-    return Array.isArray(p) ? p : [p];
+    const arr = Array.isArray(p) ? p : [p];
+    return arr.map((item) => resolveOutputParamValue(item, ctx, payload));
 }
-function runThenOrSuccess(ref, ctx) {
-    if (ref.then?.length) {
-        for (const step of ref.then) {
-            invokeRefMethod(ctx, step.reference, step.method, toParams(step.params));
+function runThenOrSuccess(def, ctx, payload) {
+    if (def.then?.length) {
+        runThenChain(def.then, 0, ctx, def, payload, () => { });
+    }
+}
+function runThenChain(steps, index, ctx, parentDef, payload, onComplete) {
+    if (index >= steps.length) {
+        onComplete();
+        return;
+    }
+    const step = steps[index];
+    const runNextSibling = () => runThenChain(steps, index + 1, ctx, parentDef, payload, onComplete);
+    const refTemplate = typeof step === 'string' ? step : step.ref;
+    const when = typeof step === 'string' ? undefined : step.when;
+    const stepParams = typeof step === 'string' ? undefined : step.params;
+    const nestedThen = typeof step === 'string' ? undefined : step.then;
+    if (!shouldRunWhen(when, ctx, payload)) {
+        runNextSibling();
+        return;
+    }
+    const resolvedCallable = resolveReferencePath(refTemplate, ctx, payload);
+    const split = splitCallableRef(resolvedCallable);
+    if (split == null) {
+        console.warn(`then chain: invalid callable ref "${resolvedCallable}" (expected e.g. Block:path.method)`);
+        return;
+    }
+    const { refPath, method } = split;
+    const callTarget = getCallTarget(refPath, ctx);
+    const fn = getMethodOnTarget(callTarget, method);
+    if (fn == null) {
+        warnNotCallable(resolvedCallable, refPath, method, callTarget);
+        return;
+    }
+    const params = resolveStepParams(stepParams, ctx, payload);
+    const result = fn.call(callTarget, ...params);
+    const afterStep = () => {
+        if (nestedThen?.length) {
+            runThenChain(nestedThen, 0, ctx, parentDef, payload, runNextSibling);
         }
+        else {
+            runNextSibling();
+        }
+    };
+    if (result != null && typeof result.then === 'function') {
+        result.then(afterStep, () => runOnError(parentDef, ctx, payload));
     }
-    else if (ref.onSuccess) {
-        invokeRefMethod(ctx, ref.onSuccess.reference, ref.onSuccess.method, toParams(ref.onSuccess.params));
+    else {
+        afterStep();
     }
 }
-function runOnError(ref, ctx) {
-    if (ref.onError) {
-        invokeRefMethod(ctx, ref.onError.reference, ref.onError.method, toParams(ref.onError.params));
+function runOnError(def, ctx, payload) {
+    if (def.onError && shouldRunWhen(def.onError.when, ctx, payload)) {
+        invokeRefMethod(ctx, def.onError.ref, payload, resolveStepParams(def.onError.params, ctx, payload));
     }
 }
-function invokeRefMethod(ctx, reference, method, params) {
-    const callTarget = getCallTarget(reference, ctx);
+function invokeRefMethod(ctx, refTemplate, payload, params) {
+    const resolvedCallable = resolveReferencePath(refTemplate, ctx, payload);
+    const split = splitCallableRef(resolvedCallable);
+    if (split == null) {
+        console.warn(`onError: invalid callable ref "${resolvedCallable}"`);
+        return;
+    }
+    const { refPath, method } = split;
+    const callTarget = getCallTarget(refPath, ctx);
     const fn = getMethodOnTarget(callTarget, method);
-    if (fn)
-        fn.call(callTarget, ...params);
+    if (fn == null) {
+        warnNotCallable(resolvedCallable, refPath, method, callTarget);
+        return;
+    }
+    fn.call(callTarget, ...params);
 }
-function createOutputHandler(outputValue, outputKey, ctx, directiveHandlers) {
-    if (isOutputReference(outputValue)) {
-        return resolveOutputReference(outputValue, undefined, ctx);
+function createOutputHandler(outputValue, _outputKey, ctx) {
+    if (typeof outputValue === 'string') {
+        return buildOutputHandlerFromCall(outputValue, {}, ctx, undefined);
     }
-    const fromDirective = directiveHandlers?.[outputKey];
-    return fromDirective ?? (() => { });
+    if (isOutputCallObject(outputValue)) {
+        return buildOutputHandlerFromCall(outputValue.ref, outputValue, ctx, undefined);
+    }
+    return () => { };
 }
 
 function getBlockInputsAndOutputs(componentOrDirectives) {
@@ -1756,7 +2490,7 @@ function getDirectiveMetadata(type) {
         isComponent: !!type.ɵcmp,
     };
 }
-function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWayKeys, ctx, outputHandlers) {
+function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWayKeys, ctx) {
     const resolvedInputs = {};
     const resolvedOutputs = {};
     const resolvedTwoWay = {};
@@ -1782,7 +2516,7 @@ function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWay
                     const valueSignal = getRefSignal(refPath, ctx);
                     if (twoWayKeys.has(key))
                         if (!isWritableSignal(valueSignal)) {
-                            console.warn(`Input "${key}" is a two-way ref but is not a writable signal.`);
+                            console.warn(`Input "${key}" of ref "${refPath}" is a two-way ref but is not a writable signal. Path might not be resolved correctly.`);
                             resolvedTwoWay[key] = linkedSignal(() => valueSignal?.());
                         }
                         else {
@@ -1796,13 +2530,24 @@ function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWay
                 continue;
             }
             const str = value;
-            if (typeof value === 'string' &&
+            const hasMustache = typeof value === 'string' &&
                 str.indexOf('{{') !== -1 &&
-                str.indexOf('}}', str.indexOf('{{')) !== -1) {
-                resolvedInputs[key] = computed(() => interpolateTemplateMixed(str, ctx));
+                str.indexOf('}}', str.indexOf('{{')) !== -1;
+            const hasFlow = typeof value === 'string' && looksLikeFlowTemplate(str);
+            if (hasMustache || hasFlow) {
+                resolvedInputs[key] = computed(() => resolveTemplateString(str, ctx, undefined, { escapeFlowRefs: true }));
                 continue;
             }
         }
+        if (Array.isArray(value)) {
+            resolvedInputs[key] = computed(() => value.map((item) => {
+                if (typeof item === 'string') {
+                    return resolveTemplateString(item, ctx, undefined, { escapeFlowRefs: true });
+                }
+                return item;
+            }));
+            continue;
+        }
         if (inputKeys.has(key))
             resolvedInputs[key] = () => value;
         if (twoWayKeys.has(key))
@@ -1813,54 +2558,10 @@ function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWay
             console.warn(`Block output "${key}" is not defined on the component or any host directive; skipping.`);
             continue;
         }
-        resolvedOutputs[key] = createOutputHandler(value, key, ctx, outputHandlers);
+        resolvedOutputs[key] = createOutputHandler(value, key, ctx);
     }
     return { resolvedInputs, resolvedOutputs, resolvedTwoWay };
 }
-function interpolateTemplateMixed(template, ctx) {
-    const trimmed = template.trim();
-    if (trimmed.startsWith('{{')) {
-        const close = trimmed.indexOf('}}', 2);
-        if (close !== -1 &&
-            close + 2 === trimmed.length &&
-            trimmed.indexOf('{{', 2) === -1) {
-            const ref = trimmed.slice(2, close).trim();
-            const resolved = resolveRefPath(ref, ctx);
-            const val = ref
-                ? resolved != null
-                    ? getRefValue(ref, ctx)
-                    : getValueByPath(ctx.currentInstance?.model?.() ?? {}, ref)
-                : null;
-            return val != null ? val : '';
-        }
-    }
-    const parts = [];
-    let s = template;
-    for (let i = 0; i < INTERPOLATE_MAX_PLACEHOLDERS; i++) {
-        const start = s.indexOf('{{');
-        if (start === -1) {
-            parts.push(s);
-            break;
-        }
-        parts.push(s.slice(0, start));
-        const end = s.indexOf('}}', start);
-        if (end === -1) {
-            parts.push(s.slice(start));
-            break;
-        }
-        const ref = s.slice(start + 2, end).trim();
-        /** Resolve ref path or get value from model if ref path is not found. */
-        const resolved = resolveRefPath(ref, ctx);
-        const val = ref
-            ? resolved != null
-                ? getRefValue(ref, ctx)
-                : getValueByPath(ctx.currentInstance?.model?.() ?? {}, ref)
-            : null;
-        parts.push(val != null ? String(val) : '');
-        s = s.slice(end + 2);
-    }
-    return parts.join('');
-}
 
 const INTERPOLATE_MAX_PLACEHOLDERS = 200;
 function createInputBindingsWithWarnings(ownerName, inputKeys, twoWayKeys, outputKeys, resolvedInputs, resolvedTwoWay, resolvedOutputs) {
@@ -1874,13 +2575,14 @@ function createInputBindingsWithWarnings(ownerName, inputKeys, twoWayKeys, outpu
         .map((key) => inputBinding(key, resolvedInputs[key]));
     const twoWayBindingsArray = Array.from(twoWayKeys)
         .filter((key) => {
-        if (resolvedTwoWay[key] == null) {
+        if (resolvedTwoWay[key] == null && resolvedInputs[key] == null) {
             return false;
         }
         return true;
     })
         // resolvedTwoWay is guaranteed non-null after the filter.
-        .map((key) => twoWayBinding(key, resolvedTwoWay[key]));
+        .map((key) => twoWayBinding(key, (resolvedTwoWay[key] ??
+        linkedSignal(() => resolvedInputs[key]?.()))));
     const outputBindingsArray = Array.from(outputKeys)
         .filter((key) => {
         if (resolvedOutputs[key] == null) {
@@ -1891,10 +2593,20 @@ function createInputBindingsWithWarnings(ownerName, inputKeys, twoWayKeys, outpu
         .map((key) => outputBinding(key, resolvedOutputs[key]));
     return [...inputBindingsArray, ...twoWayBindingsArray, ...outputBindingsArray];
 }
+/** JSON-like objects only — skip class instances, Date, Map, etc. */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
 class BlockLoaderService {
     componentRegistry = ComponentRegistry.getInstance();
     directiveRegistry = DirectiveRegistry.getInstance();
     serviceRegistry = ServiceRegistry.getInstance();
+    blockRegistryService = inject(BlockRegistryService);
     async load(description, viewContainerRef, model, options) {
         let resolved = description;
         if (isBlockReference(description)) {
@@ -1906,7 +2618,7 @@ class BlockLoaderService {
         }
         const desc = parsed.data;
         const registry = options?.registry ?? new BlockRegistryImpl();
-        if (desc.id != null && desc.id !== '' && registry.has(desc.id)) {
+        if (desc.id != null && desc.id !== '' && registry.hasLocal(desc.id)) {
             throw new Error(`Block id "${desc.id}" is already registered.`);
         }
         const componentType = await this.componentRegistry.get(desc.component);
@@ -1914,11 +2626,12 @@ class BlockLoaderService {
             throw new Error(`Component "${desc.component}" is not registered.`);
         }
         //... Generate and new resolver context
-        const blockInstance = {};
+        const blockInstance = { services: {} };
         const ctx = {
             registry,
             currentBlockId: desc.id ?? undefined,
             currentInstance: blockInstance,
+            getRegistryForScope: (scopeKey) => this.blockRegistryService.getRegistryForScope(scopeKey),
         };
         //... Resolve model for the block
         this.resolveContextModel(ctx, model);
@@ -1969,6 +2682,9 @@ class BlockLoaderService {
         return componentRef;
     }
     async resolveServices(viewContainerRef, blockInstance, desc, resolvedModel, model) {
+        // services are stored under `blockInstance.services`, so `model` no longer collides structurally,
+        // but `model` is a reserved ref keyword (`BlockId:model...`). Warn to avoid confusion.
+        const reservedAliases = new Set(['services', 'model']);
         const services = normalizeServices(desc.services);
         const selfServices = services.filter((s) => typeof s === 'object' && s.scope === 'self');
         /** Root = string id or object with scope undefined/not 'self' (e.g. [{ id: 'State' }]). */
@@ -1981,8 +2697,12 @@ class BlockLoaderService {
             const serviceType = rootServiceTypes[i];
             if (serviceType) {
                 const svc = viewContainerRef.injector.get(serviceType, null);
-                if (svc != null)
-                    blockInstance[alias] = svc;
+                if (reservedAliases.has(alias)) {
+                    console.warn(`Service alias "${alias}" is reserved and conflicts with ref keywords; skipping assignment.`);
+                }
+                else if (svc != null) {
+                    blockInstance.services[alias] = svc;
+                }
                 // if the service is not found, add it to the selfServices array
                 else
                     selfServices.push({ id: alias, scope: 'self' });
@@ -1998,12 +2718,18 @@ class BlockLoaderService {
                     self: true,
                 });
                 if (svc != null) {
-                    blockInstance[alias] = svc;
+                    if (reservedAliases.has(alias)) {
+                        console.warn(`Service alias "${alias}" is reserved and conflicts with ref keywords; skipping assignment.`);
+                    }
+                    else {
+                        blockInstance.services[alias] = svc;
+                    }
                     if (model() != null &&
                         resolvedModel != null &&
                         'model' in svc &&
                         isSignal(svc.model)) {
-                        svc.model = resolvedModel;
+                        svc.model.set(resolvedModel);
+                        svc.setModel?.();
                     }
                 }
             }
@@ -2033,22 +2759,31 @@ class BlockLoaderService {
     resolveContextModel(ctx, blockModel) {
         const directiveModel = blockModel();
         const blockInstance = ctx.currentInstance;
+        const templateCtx = this.withModelOverrideContext(ctx, blockModel);
         let blockInstanceModel;
         if (typeof directiveModel === 'string') {
-            const refPath = directiveModel;
-            if (refPath.length > 0) {
-                const refSignal = getRefSignal(refPath, ctx);
-                if (refSignal != null) {
-                    blockInstanceModel = refSignal;
-                }
-                else {
-                    console.warn(`Model ref "${directiveModel}" not found.`);
-                    return;
+            const interpolated = resolveTemplateString(directiveModel, templateCtx);
+            if (typeof interpolated !== 'string') {
+                blockInstanceModel = linkedSignal(() => resolveTemplateString(directiveModel, templateCtx));
+            }
+            else {
+                const refPath = interpolated.trim();
+                if (refPath.length > 0) {
+                    const refSignal = getRefSignal(refPath, ctx);
+                    if (refSignal != null) {
+                        blockInstanceModel = refSignal;
+                    }
+                    else {
+                        blockInstanceModel = linkedSignal(() => resolveTemplateString(directiveModel, templateCtx));
+                    }
                 }
             }
         }
         else {
-            blockInstanceModel = blockModel;
+            const hasTemplates = this.valueContainsTemplate(directiveModel);
+            blockInstanceModel = hasTemplates
+                ? linkedSignal(() => this.resolveNestedModelTemplates(blockModel(), this.withModelOverrideContext(ctx, blockModel)))
+                : blockModel;
         }
         if (blockInstanceModel != null) {
             if (!blockInstance) {
@@ -2057,10 +2792,58 @@ class BlockLoaderService {
             blockInstance.model = blockInstanceModel;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockLoaderService, providedIn: 'root' });
+    valueContainsTemplate(value, visited = new WeakSet()) {
+        if (typeof value === 'string') {
+            return value.includes('{{') && value.includes('}}');
+        }
+        if (Array.isArray(value)) {
+            return value.some((item) => this.valueContainsTemplate(item, visited));
+        }
+        if (value != null && typeof value === 'object') {
+            if (!isPlainObject(value))
+                return false;
+            if (visited.has(value))
+                return false;
+            visited.add(value);
+            return Object.values(value).some((item) => this.valueContainsTemplate(item, visited));
+        }
+        return false;
+    }
+    resolveNestedModelTemplates(value, ctx, visited = new WeakSet()) {
+        if (typeof value === 'string') {
+            return resolveTemplateString(value, ctx);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.resolveNestedModelTemplates(item, ctx, visited));
+        }
+        if (value != null && typeof value === 'object') {
+            if (!isPlainObject(value))
+                return value;
+            if (visited.has(value))
+                return value;
+            visited.add(value);
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                this.resolveNestedModelTemplates(item, ctx, visited),
+            ]));
+        }
+        return value;
+    }
+    withModelOverrideContext(ctx, model) {
+        if (ctx.currentInstance == null)
+            return ctx;
+        return {
+            ...ctx,
+            currentInstance: {
+                ...ctx.currentInstance,
+                model,
+            },
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockLoaderService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockLoaderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockLoaderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2076,25 +2859,43 @@ function getServicesKey(services) {
         : `${s.id}:${s.scope ?? ''}`)
         .join(',');
 }
+function safeJsonKey(value) {
+    try {
+        return JSON.stringify(value) ?? 'null';
+    }
+    catch {
+        return String(value);
+    }
+}
 class BlockDirective {
     viewContainerRef = inject(ViewContainerRef);
     loader = inject(BlockLoaderService);
     destroyRef = inject(DestroyRef);
     /** Full description, or { id } / { blockId, blockDefinition? } to reuse/override from blockDefinitions. */
-    description = input(null, ...(ngDevMode ? [{ debugName: "description" }] : []));
-    /** Handlers for component outputs; keys match descriptor.outputs. */
-    outputHandlers = input({}, ...(ngDevMode ? [{ debugName: "outputHandlers" }] : []));
+    description = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "description" }] : /* istanbul ignore next */ []));
     /** Registry for block instances by id; pass from root so nested blocks share it. */
-    blockRegistry = input(null, ...(ngDevMode ? [{ debugName: "blockRegistry" }] : []));
+    blockRegistry = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "blockRegistry" }] : /* istanbul ignore next */ []));
     /** Map id → full description or loader; used when description is a block reference (id/blockId). */
-    blockDefinitions = input(null, ...(ngDevMode ? [{ debugName: "blockDefinitions" }] : []));
+    blockDefinitions = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "blockDefinitions" }] : /* istanbul ignore next */ []));
     /** Model for the block. */
-    model = input(undefined, ...(ngDevMode ? [{ debugName: "model" }] : []));
+    model = input(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "model" }] : /* istanbul ignore next */ []));
+    /**
+     * 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.
+     */
+    reloadKey = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reloadKey" }] : /* istanbul ignore next */ []));
     loadResult = null;
     lastRegistry = null;
     lastId = null;
     loadedComponent = null;
     loadedServicesKey = null;
+    loadedReloadKey = null;
+    loadedDescKey = null;
     loadGeneration = 0;
     /** Invalidates in-flight block-reference resolution when the effect re-runs. */
     effectRunId = 0;
@@ -2104,8 +2905,8 @@ class BlockDirective {
     constructor() {
         effect(() => {
             const desc = this.description();
-            const outputHandlers = this.outputHandlers();
             const inputDefs = this.blockDefinitions();
+            const reloadKey = this.reloadKey();
             const runId = ++this.effectRunId;
             if (desc == null) {
                 this.lastDescRef = null;
@@ -2131,11 +2932,15 @@ class BlockDirective {
                     data = parsed.data;
                 }
                 const servicesKey = getServicesKey(data.services);
+                const descKey = safeJsonKey(resolved);
+                const effectiveReloadKey = reloadKey ?? descKey;
                 // Only clear when the logical description changed (component or services). Avoids
                 // clear+reload when the parent passes a new reference with the same content (e.g. BlockFor).
                 const mustReload = this.loadResult == null ||
                     this.loadedComponent !== data.component ||
-                    this.loadedServicesKey !== servicesKey;
+                    this.loadedServicesKey !== servicesKey ||
+                    this.loadedReloadKey !== effectiveReloadKey ||
+                    this.loadedDescKey !== descKey;
                 if (!mustReload) {
                     // Description is logically unchanged (same component + services); no work needed.
                     return;
@@ -2147,7 +2952,6 @@ class BlockDirective {
                 const generation = ++this.loadGeneration;
                 this.loader
                     .load(resolved, this.viewContainerRef, this.model, {
-                    outputHandlers: Object.keys(outputHandlers).length > 0 ? outputHandlers : undefined,
                     registry,
                     blockDefinitions: inputDefs ?? undefined,
                 })
@@ -2157,6 +2961,8 @@ class BlockDirective {
                     this.loadResult = result;
                     this.loadedComponent = data.component;
                     this.loadedServicesKey = servicesKey;
+                    this.loadedReloadKey = effectiveReloadKey;
+                    this.loadedDescKey = descKey;
                 })
                     .catch((err) => {
                     if (generation !== this.loadGeneration)
@@ -2193,18 +2999,20 @@ class BlockDirective {
             this.loadResult = null;
             this.loadedComponent = null;
             this.loadedServicesKey = null;
+            this.loadedReloadKey = null;
+            this.loadedDescKey = null;
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.0", type: BlockDirective, isStandalone: true, selector: "[block]", inputs: { description: { classPropertyName: "description", publicName: "description", isSignal: true, isRequired: false, transformFunction: null }, outputHandlers: { classPropertyName: "outputHandlers", publicName: "outputHandlers", isSignal: true, isRequired: false, transformFunction: null }, blockRegistry: { classPropertyName: "blockRegistry", publicName: "blockRegistry", isSignal: true, isRequired: false, transformFunction: null }, blockDefinitions: { classPropertyName: "blockDefinitions", publicName: "blockDefinitions", isSignal: true, isRequired: false, transformFunction: null }, model: { classPropertyName: "model", publicName: "model", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.7", type: BlockDirective, isStandalone: true, selector: "[block]", inputs: { description: { classPropertyName: "description", publicName: "description", isSignal: true, isRequired: false, transformFunction: null }, blockRegistry: { classPropertyName: "blockRegistry", publicName: "blockRegistry", isSignal: true, isRequired: false, transformFunction: null }, blockDefinitions: { classPropertyName: "blockDefinitions", publicName: "blockDefinitions", isSignal: true, isRequired: false, transformFunction: null }, model: { classPropertyName: "model", publicName: "model", isSignal: true, isRequired: false, transformFunction: null }, reloadKey: { classPropertyName: "reloadKey", publicName: "reloadKey", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[block]',
                     standalone: true,
                 }]
-        }], ctorParameters: () => [], propDecorators: { description: [{ type: i0.Input, args: [{ isSignal: true, alias: "description", required: false }] }], outputHandlers: [{ type: i0.Input, args: [{ isSignal: true, alias: "outputHandlers", required: false }] }], blockRegistry: [{ type: i0.Input, args: [{ isSignal: true, alias: "blockRegistry", required: false }] }], blockDefinitions: [{ type: i0.Input, args: [{ isSignal: true, alias: "blockDefinitions", required: false }] }], model: [{ type: i0.Input, args: [{ isSignal: true, alias: "model", required: false }] }] } });
+        }], ctorParameters: () => [], propDecorators: { description: [{ type: i0.Input, args: [{ isSignal: true, alias: "description", required: false }] }], blockRegistry: [{ type: i0.Input, args: [{ isSignal: true, alias: "blockRegistry", required: false }] }], blockDefinitions: [{ type: i0.Input, args: [{ isSignal: true, alias: "blockDefinitions", required: false }] }], model: [{ type: i0.Input, args: [{ isSignal: true, alias: "model", required: false }] }], reloadKey: [{ type: i0.Input, args: [{ isSignal: true, alias: "reloadKey", required: false }] }] } });
 
 /*
  * Public API Surface of blocks-studio
@@ -2214,5 +3022,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-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 { 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 };
 //# sourceMappingURL=ngx-blocks-studio.mjs.map