@ixo/editor 5.10.1 → 5.12.0

package/dist/{decompile-BKY8P5Q_.d.ts → store-BT916StR.d.ts}

@@ -1,6 +1,6 @@
-import { Y as FlowNode, a1 as FlowNodeAuthzExtension, a2 as FlowNodeRuntimeState, W as IxoEditorType, f as UcanService, I as InvocationStore, $ as EvaluationStatus } from './index-DKKQa1q-.mjs';
+import { Z as FlowNode, a2 as FlowNodeAuthzExtension, X as FlowNodeRuntimeState, W as IxoEditorType, f as UcanService, I as InvocationStore, a0 as EvaluationStatus, i as UcanCapability, U as UcanDelegationStore, S as StoredDelegation } from './index-C0ikjICf.mjs';
 import * as Y from 'yjs';
-import { Doc } from 'yjs';
+import { Doc, Map } from 'yjs';
 import { MatrixClient } from 'matrix-js-sdk';
 
 /** Condition that gates when a capability activates. */
@@ -954,4 +954,229 @@ declare function readCompiledFlowFromYDoc(yDoc: Doc): CompiledFlow | null;
  */
 declare function decompileToBaseUcanFlow(compiled: CompiledFlow): BaseUcanFlow;
 
-export { type AuthorizationResult as A, type BaseUcanFlow as B, type CompilerRegistry as C, type ActionContext as D, type ExecuteNodeParams as E, type FlowRuntimeStateManager as F, type ActionResult as G, type ConditionRef as H, type ActorConstraint as I, type RuntimeRef as J, type CompiledBlock as K, type CompiledEdge as L, type MergeResult as M, type NodeActionResult as N, type OutputSchemaField as O, type CompiledFlowNode as P, type TriggerSpec as Q, type ReadFlowOptions as R, type SetupFlowOptions as S, type TTLConstraint as T, isRuntimeRef as U, buildAuthzFromProps as a, buildFlowNodeFromBlock as b, createRuntimeStateManager as c, type ExecutionOutcome as d, executeNode as e, type ExecutionContext as f, readFlowFromEditor as g, readFlow as h, isAuthorized as i, setActiveEditor as j, getActiveEditor as k, compileBaseUcanFlow as l, readCompiledFlowFromYDoc as m, mergeCompiledFlows as n, decompileToBaseUcanFlow as o, type SetupFlowResult as p, type ReadFlowResult as q, readFlowAsBaseUcan as r, setupFlowFromBaseUcan as s, type ReadableEditor as t, type FlowCapability as u, type CompiledFlow as v, type FlowStrategy as w, type ActionDefinition as x, type ActionServices as y, clearRuntimeForTemplateClone as z };
+type FlowAgentPublicNodeState = 'Pending' | 'Blocked' | 'Overdue' | 'Done';
+type FlowAgentRunPhase = 'Running' | 'Validating' | 'Failed' | 'Archived';
+type FlowAgentBlockerCause = 'missing_input' | 'failed_upstream' | 'missing_ucan' | 'stale_config' | 'service_error' | 'external_confirmation_pending' | 'validation_mismatch' | 'unknown';
+type FlowAgentCommandType = 'diagnose_blocker' | 'assign_actor' | 'notify_actor' | 'execute_action' | 'validate_external_state' | 'submit_claim' | 'watch_udid' | 'archive_flow' | 'propose_config_change';
+type FlowAgentCommandStatus = 'queued' | 'leased' | 'running' | 'confirmed' | 'failed' | 'skipped';
+type FlowAgentLedgerEventType = 'agent.decision' | 'agent.command' | 'agent.validation' | 'agent.escalation' | 'agent.memory';
+interface FlowAgentActor {
+    did: string;
+    matrixUserId?: string;
+    displayName?: string;
+    skills?: string[];
+}
+interface FlowAgentLease {
+    id: string;
+    commandId: string;
+    nodeId: string;
+    actorDid: string;
+    acquiredAt: number;
+    expiresAt: number;
+    epoch: number;
+}
+interface FlowAgentNodeSnapshot {
+    nodeId: string;
+    blockType: string;
+    actionType?: string;
+    title?: string;
+    runtime: FlowNodeRuntimeState;
+    publicState: FlowAgentPublicNodeState;
+    blockerCause?: FlowAgentBlockerCause;
+    assigneeDid?: string;
+    dueAt?: number;
+    pendingInvocationCount: number;
+}
+interface FlowAgentCommandBase {
+    id: string;
+    type: FlowAgentCommandType;
+    flowId: string;
+    flowUri: string;
+    nodeId: string;
+    actorDid: string;
+    status: FlowAgentCommandStatus;
+    capability: UcanCapability;
+    idempotencyKey: string;
+    createdAt: number;
+    updatedAt: number;
+    reason: string;
+    payload: Record<string, unknown>;
+    lease?: FlowAgentLease;
+    error?: string;
+}
+type FlowAgentCommand = FlowAgentCommandBase;
+interface FlowAgentLedgerEvent {
+    id: string;
+    type: FlowAgentLedgerEventType;
+    flowId: string;
+    nodeId?: string;
+    commandId?: string;
+    actorDid: string;
+    timestamp: number;
+    details: Record<string, unknown>;
+}
+interface FlowAgentMaps {
+    outbox: Map<FlowAgentCommand>;
+    leases: Map<FlowAgentLease>;
+}
+interface FlowAgentPolicyDecision {
+    allowed: boolean;
+    reason: string;
+    capability: UcanCapability;
+    proofCids: string[];
+}
+interface FlowAgentContext {
+    yDoc: Doc;
+    editor?: IxoEditorType;
+    blocks?: unknown[];
+    flowId: string;
+    flowUri: string;
+    actor: FlowAgentActor;
+    now?: () => number;
+}
+interface FlowAgentCommandResult {
+    commandId: string;
+    success: boolean;
+    output?: Record<string, unknown>;
+    confirmed?: boolean;
+    error?: string;
+}
+interface FlowAgentExecutor {
+    executeAction?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    assignActor?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    notifyActor?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    validateExternalState?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    submitClaim?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    watchUdid?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    archiveFlow?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    proposeConfigChange?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+    diagnoseBlocker?: (command: FlowAgentCommand, context: FlowAgentContext) => Promise<FlowAgentCommandResult>;
+}
+interface FlowAgentTickResult {
+    flowDone: boolean;
+    snapshots: FlowAgentNodeSnapshot[];
+    queuedCommands: FlowAgentCommand[];
+    executedCommands: FlowAgentCommandResult[];
+}
+
+interface CreateAgentCommandParams {
+    type: FlowAgentCommandType;
+    flowId: string;
+    flowUri: string;
+    nodeId: string;
+    actor: FlowAgentActor;
+    reason: string;
+    payload?: Record<string, unknown>;
+    now?: number;
+}
+declare function createAgentCommand({ type, flowId, flowUri, nodeId, actor, reason, payload, now }: CreateAgentCommandParams): FlowAgentCommand;
+declare function validateAgentCommand(command: FlowAgentCommand): {
+    valid: boolean;
+    error?: string;
+};
+declare function isExternalMutation(type: FlowAgentCommandType): boolean;
+
+interface BuildFlowAgentContextParams {
+    yDoc: Doc;
+    flowId: string;
+    flowUri?: string;
+    actor: FlowAgentActor;
+    blocks?: unknown[];
+    editor?: IxoEditorType;
+    now?: () => number;
+}
+/**
+ * Builds the host-facing runtime context expected by the Flow Agent.
+ *
+ * Headless hosts own Matrix login, room joins, and Y.Doc sync. Once a host has
+ * a live room document and an agent identity, this helper gives it the stable
+ * context shape to pass into `tickFlowAgent` or `FlowAgentService`.
+ */
+declare function buildFlowAgentContext({ yDoc, flowId, flowUri, actor, blocks, editor, now }: BuildFlowAgentContextParams): FlowAgentContext;
+
+interface AcquireFlowAgentLeaseParams {
+    leases: Map<FlowAgentLease>;
+    commandId: string;
+    nodeId: string;
+    actorDid: string;
+    now?: number;
+    ttlMs?: number;
+}
+declare function acquireFlowAgentLease({ leases, commandId, nodeId, actorDid, now, ttlMs, }: AcquireFlowAgentLeaseParams): FlowAgentLease | null;
+declare function validateFlowAgentLease(leases: Map<FlowAgentLease>, lease: FlowAgentLease, now?: number): boolean;
+declare function releaseFlowAgentLease(leases: Map<FlowAgentLease>, lease: FlowAgentLease): boolean;
+declare function cleanupExpiredFlowAgentLeases(leases: Map<FlowAgentLease>, now?: number): FlowAgentLease[];
+
+declare function requiredCapabilityForCommand(type: FlowAgentCommandType, flowUri: string, nodeId: string): UcanCapability;
+declare function isCapabilityMatch(granted: UcanCapability, required: UcanCapability): boolean;
+declare function canMatches(granted: string, required: string): boolean;
+declare function resourceMatches(granted: string, required: string): boolean;
+interface EvaluateFlowAgentPolicyParams {
+    actorDid: string;
+    commandType: FlowAgentCommandType;
+    flowUri: string;
+    nodeId: string;
+    delegationStore?: UcanDelegationStore;
+    delegations?: StoredDelegation[];
+    now?: number;
+}
+declare function evaluateFlowAgentPolicy({ actorDid, commandType, flowUri, nodeId, delegationStore, delegations, now, }: EvaluateFlowAgentPolicyParams): FlowAgentPolicyDecision;
+
+interface FlowAgentOrchestratorOptions {
+    delegationStore?: UcanDelegationStore;
+    delegations?: StoredDelegation[];
+    candidateActors?: FlowAgentActor[];
+    executor?: FlowAgentExecutor;
+    leaseTtlMs?: number;
+    archiveWhenDone?: boolean;
+}
+declare function planRalphLoopCommands(context: FlowAgentContext, options?: FlowAgentOrchestratorOptions): {
+    snapshots: FlowAgentNodeSnapshot[];
+    queuedCommands: FlowAgentCommand[];
+    flowDone: boolean;
+};
+declare function executeQueuedAgentCommands(context: FlowAgentContext, options?: FlowAgentOrchestratorOptions): Promise<FlowAgentCommandResult[]>;
+declare function tickFlowAgent(context: FlowAgentContext, options?: FlowAgentOrchestratorOptions): Promise<FlowAgentTickResult>;
+
+interface FlowAgentServiceOptions extends FlowAgentOrchestratorOptions {
+    intervalMs?: number;
+    onTick?: (result: FlowAgentTickResult) => void | Promise<void>;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Headless-service adapter boundary.
+ *
+ * Host applications own Matrix login, room joins, and Y.Doc sync. Once they
+ * have a live Y.Doc/editor snapshot, this service provides the deterministic
+ * Ralph-loop tick and command execution cycle.
+ */
+declare class FlowAgentService {
+    private readonly context;
+    private readonly options;
+    private timer;
+    private running;
+    constructor(context: FlowAgentContext, options?: FlowAgentServiceOptions);
+    tick(): Promise<FlowAgentTickResult>;
+    start(): void;
+    stop(): void;
+}
+
+declare function getFlowAgentMaps(yDoc: Doc): FlowAgentMaps;
+declare function computeAgentCommandId(params: {
+    flowId: string;
+    nodeId: string;
+    type: string;
+    payload: Record<string, unknown>;
+}): string;
+declare function queueAgentCommand(yDoc: Doc, command: FlowAgentCommand): {
+    command: FlowAgentCommand;
+    created: boolean;
+};
+declare function readQueuedAgentCommands(yDoc: Doc): FlowAgentCommand[];
+declare function updateAgentCommand(yDoc: Doc, commandId: string, patch: Partial<FlowAgentCommand>): FlowAgentCommand | null;
+declare function appendAgentLedgerEvent(yDoc: Doc, event: Omit<FlowAgentLedgerEvent, 'id'> & {
+    id?: string;
+}): FlowAgentLedgerEvent;
+declare function readAgentLedgerEvents(yDoc: Doc, eventType?: FlowAgentLedgerEventType): FlowAgentLedgerEvent[];
+
+export { type FlowAgentContext as $, type AuthorizationResult as A, type BaseUcanFlow as B, type CompilerRegistry as C, buildFlowAgentContext as D, type ExecuteNodeParams as E, type FlowRuntimeStateManager as F, cleanupExpiredFlowAgentLeases as G, createAgentCommand as H, evaluateFlowAgentPolicy as I, executeQueuedAgentCommands as J, getFlowAgentMaps as K, planRalphLoopCommands as L, type MergeResult as M, type NodeActionResult as N, queueAgentCommand as O, readAgentLedgerEvents as P, readQueuedAgentCommands as Q, type ReadFlowOptions as R, type SetupFlowOptions as S, releaseFlowAgentLease as T, tickFlowAgent as U, validateAgentCommand as V, validateFlowAgentLease as W, type BuildFlowAgentContextParams as X, type FlowAgentActor as Y, type FlowAgentCommand as Z, type FlowAgentCommandResult as _, buildAuthzFromProps as a, type FlowAgentExecutor as a0, type FlowAgentLease as a1, type FlowAgentNodeSnapshot as a2, type FlowAgentPublicNodeState as a3, type FlowAgentTickResult as a4, type ActionDefinition as a5, type ActionServices as a6, type FlowAgentBlockerCause as a7, clearRuntimeForTemplateClone as a8, type ActionContext as a9, type CompiledBlock as aA, type CompiledEdge as aB, type CompiledFlowNode as aC, type TriggerSpec as aD, isRuntimeRef as aE, type ActionResult as aa, type OutputSchemaField as ab, canMatches as ac, computeAgentCommandId as ad, isCapabilityMatch as ae, isExternalMutation as af, requiredCapabilityForCommand as ag, resourceMatches as ah, updateAgentCommand as ai, type AcquireFlowAgentLeaseParams as aj, type CreateAgentCommandParams as ak, type EvaluateFlowAgentPolicyParams as al, type FlowAgentOrchestratorOptions as am, type FlowAgentServiceOptions as an, type FlowAgentCommandBase as ao, type FlowAgentCommandStatus as ap, type FlowAgentCommandType as aq, type FlowAgentLedgerEvent as ar, type FlowAgentLedgerEventType as as, type FlowAgentMaps as at, type FlowAgentPolicyDecision as au, type FlowAgentRunPhase as av, type ConditionRef as aw, type ActorConstraint as ax, type TTLConstraint as ay, type RuntimeRef as az, buildFlowNodeFromBlock as b, createRuntimeStateManager as c, type ExecutionOutcome as d, executeNode as e, type ExecutionContext as f, readFlowFromEditor as g, readFlow as h, isAuthorized as i, setActiveEditor as j, getActiveEditor as k, compileBaseUcanFlow as l, readCompiledFlowFromYDoc as m, mergeCompiledFlows as n, decompileToBaseUcanFlow as o, type SetupFlowResult as p, type ReadFlowResult as q, readFlowAsBaseUcan as r, setupFlowFromBaseUcan as s, type ReadableEditor as t, type FlowCapability as u, type CompiledFlow as v, type FlowStrategy as w, FlowAgentService as x, acquireFlowAgentLease as y, appendAgentLedgerEvent as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ixo/editor",
-  "version": "5.10.1",
+  "version": "5.12.0",
   "description": "A custom BlockNote editor wrapper for IXO team",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",

package/dist/chunk-UKZ5T7V4.mjs

@@ -1,63 +0,0 @@
-import {
-  isRuntimeRef
-} from "./chunk-DQCYLHDD.mjs";
-
-// src/core/lib/flowCompiler/resolveRefs.ts
-function resolveRuntimeRefs(nb, getNodeOutput, triggerContext) {
-  return resolveValue(nb, getNodeOutput, triggerContext);
-}
-function resolveValue(value, getNodeOutput, triggerContext) {
-  if (isRuntimeRef(value)) {
-    return resolveRef(value.$ref, getNodeOutput, triggerContext);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => resolveValue(item, getNodeOutput, triggerContext));
-  }
-  if (typeof value === "object" && value !== null) {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      result[key] = resolveValue(val, getNodeOutput, triggerContext);
-    }
-    return result;
-  }
-  return value;
-}
-function resolveRef(ref, getNodeOutput, triggerContext) {
-  if (ref.startsWith("trigger.payload.")) {
-    if (!triggerContext) {
-      throw new Error(`Trigger ref "${ref}" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);
-    }
-    const fieldPath2 = ref.slice("trigger.payload.".length);
-    return getNestedValue(triggerContext.payload, fieldPath2);
-  }
-  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {
-    return triggerContext.refSnapshots[ref];
-  }
-  const outputIndex = ref.indexOf(".output.");
-  if (outputIndex === -1) {
-    throw new Error(`Invalid runtime reference "${ref}". Expected format: "nodeId.output.fieldPath" or "trigger.payload.fieldPath"`);
-  }
-  const nodeId = ref.slice(0, outputIndex);
-  const fieldPath = ref.slice(outputIndex + ".output.".length);
-  const output = getNodeOutput(nodeId);
-  if (!output) {
-    return void 0;
-  }
-  return getNestedValue(output, fieldPath);
-}
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-
-export {
-  resolveRuntimeRefs
-};
-//# sourceMappingURL=chunk-UKZ5T7V4.mjs.map

package/dist/chunk-UKZ5T7V4.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/lib/flowCompiler/resolveRefs.ts"],"sourcesContent":["import { isRuntimeRef } from '../../types/baseUcan';\n\n/**\n * Context passed to resolveRuntimeRefs when resolving inputs for a triggered\n * listener block. The runtime constructs this from a PendingInvocation when\n * the assignee invokes the listener.\n *\n * - `payload`: the frozen event payload, used to resolve `trigger.payload.*` refs\n * - `refSnapshots`: frozen `nodeId.output.*` values captured at queue time,\n *   used to resolve those refs against the moment of emission rather than\n *   current state. See docs/events-and-triggers-plan.md §3.5.1 for the\n *   Sally → Mike scenario this fixes.\n */\nexport interface TriggerResolutionContext {\n  payload: Record<string, unknown>;\n  refSnapshots: Record<string, unknown>;\n}\n\n/**\n * Resolve runtime references in an nb (caveats) object.\n *\n * At compile time, `{ \"$ref\": \"nodeId.output.fieldPath\" }` values are serialized\n * as-is into the block's `inputs` JSON string. At execution time, this function\n * replaces them with actual output values from upstream nodes.\n *\n * Two ref namespaces are supported:\n *  - `nodeId.output.fieldPath` — looked up via `getNodeOutput`. When a\n *    `triggerContext` is provided AND `refSnapshots[ref]` exists, the\n *    snapshot is preferred over the live lookup. This is the load-bearing\n *    fix for the lag-time scenario where multiple pending invocations are\n *    queued and the source block re-runs before the assignee acts on them.\n *  - `trigger.payload.fieldPath` — looked up in `triggerContext.payload`.\n *    Only valid when `triggerContext` is provided (i.e. resolving inputs\n *    for a triggered listener invocation). Compile-time validation in\n *    compiler.ts guarantees these only appear on `block.event`-triggered\n *    blocks.\n *\n * @param nb - The caveats object (may contain nested RuntimeRef values)\n * @param getNodeOutput - Lookup function for upstream node outputs\n * @param triggerContext - Optional, present only for triggered listener invocations\n * @returns A new object with all $ref values resolved\n */\nexport function resolveRuntimeRefs(\n  nb: Record<string, unknown>,\n  getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined,\n  triggerContext?: TriggerResolutionContext\n): Record<string, unknown> {\n  return resolveValue(nb, getNodeOutput, triggerContext) as Record<string, unknown>;\n}\n\nfunction resolveValue(value: unknown, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined, triggerContext?: TriggerResolutionContext): unknown {\n  if (isRuntimeRef(value)) {\n    return resolveRef(value.$ref, getNodeOutput, triggerContext);\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => resolveValue(item, getNodeOutput, triggerContext));\n  }\n\n  if (typeof value === 'object' && value !== null) {\n    const result: Record<string, unknown> = {};\n    for (const [key, val] of Object.entries(value)) {\n      result[key] = resolveValue(val, getNodeOutput, triggerContext);\n    }\n    return result;\n  }\n\n  return value;\n}\n\n/**\n * Resolve a single $ref string.\n *\n * Supported forms:\n *   - \"trigger.payload.fieldPath\" — looked up in triggerContext.payload\n *   - \"nodeId.output.fieldPath\" — looked up in triggerContext.refSnapshots first\n *     (if present), falling back to getNodeOutput. Snapshot preference is\n *     what makes the Sally → Mike scenario produce frozen values per pending\n *     invocation.\n */\nfunction resolveRef(ref: string, getNodeOutput: (nodeId: string) => Record<string, unknown> | undefined, triggerContext?: TriggerResolutionContext): unknown {\n  // trigger.payload.* — only valid when a triggerContext is provided\n  if (ref.startsWith('trigger.payload.')) {\n    if (!triggerContext) {\n      throw new Error(`Trigger ref \"${ref}\" used outside of a listener invocation context. trigger.payload.* refs are only valid on block.event-triggered blocks.`);\n    }\n    const fieldPath = ref.slice('trigger.payload.'.length);\n    return getNestedValue(triggerContext.payload, fieldPath);\n  }\n\n  // nodeId.output.fieldPath — prefer the snapshot if we're inside a trigger context\n  if (triggerContext && Object.prototype.hasOwnProperty.call(triggerContext.refSnapshots, ref)) {\n    return triggerContext.refSnapshots[ref];\n  }\n\n  // Parse \"nodeId.output.fieldPath\"\n  const outputIndex = ref.indexOf('.output.');\n  if (outputIndex === -1) {\n    throw new Error(`Invalid runtime reference \"${ref}\". Expected format: \"nodeId.output.fieldPath\" or \"trigger.payload.fieldPath\"`);\n  }\n\n  const nodeId = ref.slice(0, outputIndex);\n  const fieldPath = ref.slice(outputIndex + '.output.'.length);\n\n  const output = getNodeOutput(nodeId);\n  if (!output) {\n    return undefined;\n  }\n\n  // Traverse the field path (supports dot notation)\n  return getNestedValue(output, fieldPath);\n}\n\nfunction getNestedValue(obj: Record<string, unknown>, path: string): unknown {\n  const parts = path.split('.');\n  let current: unknown = obj;\n\n  for (const part of parts) {\n    if (current == null || typeof current !== 'object') {\n      return undefined;\n    }\n    current = (current as Record<string, unknown>)[part];\n  }\n\n  return current;\n}\n"],"mappings":";;;;;AA0CO,SAAS,mBACd,IACA,eACA,gBACyB;AACzB,SAAO,aAAa,IAAI,eAAe,cAAc;AACvD;AAEA,SAAS,aAAa,OAAgB,eAAwE,gBAAoD;AAChK,MAAI,aAAa,KAAK,GAAG;AACvB,WAAO,WAAW,MAAM,MAAM,eAAe,cAAc;AAAA,EAC7D;AAEA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO,MAAM,IAAI,CAAC,SAAS,aAAa,MAAM,eAAe,cAAc,CAAC;AAAA,EAC9E;AAEA,MAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,UAAM,SAAkC,CAAC;AACzC,eAAW,CAAC,KAAK,GAAG,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC9C,aAAO,GAAG,IAAI,aAAa,KAAK,eAAe,cAAc;AAAA,IAC/D;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAYA,SAAS,WAAW,KAAa,eAAwE,gBAAoD;AAE3J,MAAI,IAAI,WAAW,kBAAkB,GAAG;AACtC,QAAI,CAAC,gBAAgB;AACnB,YAAM,IAAI,MAAM,gBAAgB,GAAG,yHAAyH;AAAA,IAC9J;AACA,UAAMA,aAAY,IAAI,MAAM,mBAAmB,MAAM;AACrD,WAAO,eAAe,eAAe,SAASA,UAAS;AAAA,EACzD;AAGA,MAAI,kBAAkB,OAAO,UAAU,eAAe,KAAK,eAAe,cAAc,GAAG,GAAG;AAC5F,WAAO,eAAe,aAAa,GAAG;AAAA,EACxC;AAGA,QAAM,cAAc,IAAI,QAAQ,UAAU;AAC1C,MAAI,gBAAgB,IAAI;AACtB,UAAM,IAAI,MAAM,8BAA8B,GAAG,8EAA8E;AAAA,EACjI;AAEA,QAAM,SAAS,IAAI,MAAM,GAAG,WAAW;AACvC,QAAM,YAAY,IAAI,MAAM,cAAc,WAAW,MAAM;AAE3D,QAAM,SAAS,cAAc,MAAM;AACnC,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AAGA,SAAO,eAAe,QAAQ,SAAS;AACzC;AAEA,SAAS,eAAe,KAA8B,MAAuB;AAC3E,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,UAAmB;AAEvB,aAAW,QAAQ,OAAO;AACxB,QAAI,WAAW,QAAQ,OAAO,YAAY,UAAU;AAClD,aAAO;AAAA,IACT;AACA,cAAW,QAAoC,IAAI;AAAA,EACrD;AAEA,SAAO;AACT;","names":["fieldPath"]}