graphddb 0.5.3 → 0.6.0

package/dist/cdc/index.d.ts

@@ -1,5 +1,5 @@
-export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from '../from-change-DQK2Jm9R.js';
-export { B as BatchResult, C as CdcEmulatorOptions, a as CdcMode, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, g as ConcurrentRecomputeRef, E as EventLog, F as FaultSpec, R as ReplayOptions, S as ShardId, h as StartingPosition, i as StreamViewType, j as SubscribeHandler, k as SubscribeHandlers, U as Unsubscribe, l as buildSubscribeHandler } from '../maintenance-view-adapter-D5t9taTE.js';
+export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from '../from-change-CFzBy7aU.js';
+export { B as BatchResult, C as CdcEmulatorOptions, a as CdcMode, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, g as ConcurrentRecomputeRef, E as EventLog, F as FaultSpec, R as ReplayOptions, S as ShardId, h as StartingPosition, i as StreamViewType, j as SubscribeHandler, k as SubscribeHandlers, U as Unsubscribe, l as buildSubscribeHandler } from '../maintenance-view-adapter-CFeasCKo.js';
 import '@aws-sdk/client-dynamodb';
 
 /**

package/dist/cdc/index.js

@@ -8,11 +8,11 @@ import {
   createMaintenanceDrainHandler,
   hashString,
   shardIdFor
-} from "../chunk-M6URQOAW.js";
+} from "../chunk-5NXNEW43.js";
 import {
   buildSubscribeHandler,
   parseChange
-} from "../chunk-CCIVET5K.js";
+} from "../chunk-F2DI3GTI.js";
 import "../chunk-PDUVTYC5.js";
 export {
   CdcEmulator,

package/dist/{chunk-M6URQOAW.js → chunk-5NXNEW43.js}

@@ -7,7 +7,7 @@ import {
   buildMaintenanceGraph,
   buildPutInput,
   resolveModelClass
-} from "./chunk-CCIVET5K.js";
+} from "./chunk-F2DI3GTI.js";
 
 // src/cdc/prng.ts
 var SeededRandom = class {

package/dist/{chunk-CCIVET5K.js → chunk-F2DI3GTI.js}

@@ -245,6 +245,73 @@ function buildRelation(select) {
   });
 }
 
+// src/relation/detect.ts
+function isRelationSpec(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return "select" in value || isSelectBuilder(value);
+}
+function isInlineSnapshotSpec(value) {
+  return typeof value === "object" && value !== null && !isSelectBuilder(value) && value.inline === true && !("select" in value);
+}
+function detectRelationFields(select, metadata) {
+  const result = [];
+  for (const [fieldName, value] of Object.entries(select)) {
+    if (isRelationSpec(value)) {
+      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
+      if (rel) {
+        result.push(rel);
+      }
+    }
+  }
+  return result;
+}
+function validateInlineSnapshotSelect(select, metadata, resolveTargetMeta) {
+  for (const [fieldName, value] of Object.entries(select)) {
+    if (isInlineSnapshotSpec(value)) {
+      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
+      if (!rel) {
+        throw new Error(
+          `Inline read '{ ${fieldName}: { inline: true } }' is only valid on an embeddedSnapshot relation, but '${fieldName}' is not a relation on '${metadata.prefix}'. Use '${fieldName}: true' for a scalar / embedded field.`
+        );
+      }
+      if (rel.options?.pattern !== "embeddedSnapshot") {
+        throw new Error(
+          `Inline read '{ ${fieldName}: { inline: true } }' is only valid on an embeddedSnapshot relation. '${fieldName}' is a plain '${rel.type}' relation (no 'pattern: embeddedSnapshot'); use '{ ${fieldName}: { select: \u2026 } }' to traverse to its child rows instead.`
+        );
+      }
+      continue;
+    }
+    if (typeof value === "object" && value !== null && isRelationSpec(value)) {
+      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
+      if (!rel) continue;
+      const targetMeta = resolveTargetMeta(rel);
+      const nested = normalizeSelectSpec(value).select;
+      if (nested) {
+        validateInlineSnapshotSelect(nested, targetMeta, resolveTargetMeta);
+      }
+    }
+  }
+}
+function getImplicitKeyFields(select, metadata) {
+  const relations = detectRelationFields(select, metadata);
+  const needed = /* @__PURE__ */ new Set();
+  for (const rel of relations) {
+    if (rel.type === "refs" && rel.refs) {
+      const listField = rel.refs.from;
+      if (!(listField in select) || select[listField] !== true) {
+        needed.add(listField);
+      }
+      continue;
+    }
+    for (const sourceField of Object.values(rel.keyBinding)) {
+      if (!(sourceField in select) || select[sourceField] !== true) {
+        needed.add(sourceField);
+      }
+    }
+  }
+  return [...needed];
+}
+
 // src/define/param.ts
 function isParamOptions(value) {
   return typeof value === "object" && value !== null;
@@ -2718,6 +2785,11 @@ function hydrateItem(raw, select, metadata, updatable = false) {
         const fieldMeta = fieldMap.get(fieldName);
         result[fieldName] = deserializeValue(value, fieldMeta);
       }
+    } else if (isInlineSnapshotSpec(selectValue)) {
+      const value = raw[fieldName];
+      if (value !== void 0) {
+        result[fieldName] = value;
+      }
     } else if (typeof selectValue === "object" && selectValue !== null) {
       if ("select" in selectValue || isSelectBuilder(selectValue)) {
         continue;
@@ -2856,6 +2928,18 @@ var recorder = {
   deleteEdge(targetFactory, relationProperty) {
     return { kind: "deleteEdge", targetFactory, relationProperty };
   },
+  dualEdge(forward, inverse) {
+    return {
+      kind: "putEdge",
+      targetFactory: forward.target,
+      relationProperty: forward.relationProperty,
+      inverse: {
+        adjacencyFactory: inverse.adjacency,
+        targetFactory: inverse.target,
+        relationProperty: inverse.relationProperty
+      }
+    };
+  },
   increment(targetFactory, keys, attribute, amount) {
     return { kind: "derive", targetFactory, keys, attribute, amount };
   },
@@ -3713,6 +3797,10 @@ export {
   normalizeTopLevelSelect,
   buildProject,
   buildRelation,
+  isInlineSnapshotSpec,
+  detectRelationFields,
+  validateInlineSnapshotSelect,
+  getImplicitKeyFields,
   param,
   isParam,
   BATCH_GET_MAX_KEYS,

package/dist/{chunk-Y7XV5QL2.js → chunk-N5NQM3SO.js}

@@ -22,14 +22,17 @@ import {
   commitTransaction,
   compileRawCondition,
   ctxModelFor,
+  detectRelationFields,
   execItemKeySignature,
   executeDelete,
   executePut,
   executeTransaction,
   executeUpdate,
   getEntityWrites,
+  getImplicitKeyFields,
   hydrate,
   isEntityWritesDefinition,
+  isInlineSnapshotSpec,
   isLifecycleContract,
   isParam,
   isRawCondition,
@@ -44,8 +47,9 @@ import {
   resolveSegmentedKey,
   serializeFieldValue,
   serializeRawCondition,
-  skTemplate
-} from "./chunk-CCIVET5K.js";
+  skTemplate,
+  validateInlineSnapshotSelect
+} from "./chunk-F2DI3GTI.js";
 import {
   TableMapping,
   createColumnMap,
@@ -116,6 +120,10 @@ function buildRelations(metadata) {
       type: rel.type,
       target: targetClass.name,
       keyBinding: { ...rel.keyBinding },
+      // List-valued source descriptor for a `refs` relation (issue #197); emitted
+      // only for `refs` so a scalar-keyed relation is byte-identical to the pre-#197
+      // manifest.
+      ...rel.refs !== void 0 ? { refs: { ...rel.refs } } : {},
       // Purely-documentary relation description (issue #166); emitted only when
       // declared so an undescribed relation is byte-identical to the pre-#166 manifest.
       ...rel.options?.description !== void 0 ? { description: rel.options.description } : {}
@@ -190,36 +198,6 @@ function buildManifest(registry = MetadataRegistry) {
   };
 }
 
-// src/relation/detect.ts
-function isRelationSpec(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return "select" in value || isSelectBuilder(value);
-}
-function detectRelationFields(select, metadata) {
-  const result = [];
-  for (const [fieldName, value] of Object.entries(select)) {
-    if (isRelationSpec(value)) {
-      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
-      if (rel) {
-        result.push(rel);
-      }
-    }
-  }
-  return result;
-}
-function getImplicitKeyFields(select, metadata) {
-  const relations = detectRelationFields(select, metadata);
-  const needed = /* @__PURE__ */ new Set();
-  for (const rel of relations) {
-    for (const sourceField of Object.values(rel.keyBinding)) {
-      if (!(sourceField in select) || select[sourceField] !== true) {
-        needed.add(sourceField);
-      }
-    }
-  }
-  return [...needed];
-}
-
 // src/planner/projection.ts
 function buildProjection(select, additionalFields) {
   const paths = [];
@@ -237,6 +215,8 @@ function buildProjection(select, additionalFields) {
     for (const [fieldName, value] of Object.entries(selectObj)) {
       if (value === true) {
         addPath([...parentSegments, fieldName]);
+      } else if (isInlineSnapshotSpec(value)) {
+        addPath([...parentSegments, fieldName]);
       } else if (typeof value === "object" && value !== null) {
         if ("select" in value || isSelectBuilder(value)) {
           continue;
@@ -702,6 +682,11 @@ async function executeListInternal(modelClass, key, selectSpec, options = {}) {
   const after = options.after ?? normalized.after;
   const limit = options.limit ?? normalized.limit;
   const order = options.order ?? normalized.order;
+  validateInlineSnapshotSelect(
+    select,
+    metadata,
+    (rel) => MetadataRegistry.get(rel.targetFactory())
+  );
   const exclusiveStartKey = after ? decodeCursor(after) : void 0;
   const implicitKeys = getImplicitKeyFields(select, metadata);
   const executionPlan = plan(metadata, {
@@ -970,7 +955,7 @@ function relationResultPaths(select, metadata, parentPath = "$") {
     const childSelect = normalizeSelectSpec(select[rel.propertyName]).select ?? {};
     const targetMeta = MetadataRegistry.get(rel.targetFactory());
     const childPath = `${parentPath}.${rel.propertyName}`;
-    const isMany = rel.type === "hasMany";
+    const isMany = rel.type === "hasMany" || rel.type === "refs";
     const resultPath = isMany ? `${childPath}.items` : childPath;
     out.push({
       propertyName: rel.propertyName,
@@ -1064,7 +1049,7 @@ function validateDepth(select, metadata, maxDepth, currentDepth = 1) {
 }
 function relationResultPath(parentPath, rel) {
   const base = `${parentPath}.${rel.propertyName}`;
-  return rel.type === "hasMany" ? `${base}.items` : base;
+  return rel.type === "hasMany" || rel.type === "refs" ? `${base}.items` : base;
 }
 function stageRelations(relations, parentPath, plan2) {
   if (plan2 === void 0 || relations.length === 0) {
@@ -1188,6 +1173,95 @@ async function fetchBelongsToHasOneBatch(rel, rawParentItems, selectSpec, target
   );
   return results;
 }
+async function fetchRefsList(rel, rawParentItem, selectSpec, targetMeta, options, currentDepth, ownPath) {
+  const refsBinding = rel.refs;
+  if (!refsBinding) {
+    throw new Error(
+      `Relation '${rel.propertyName}' is type 'refs' but carries no refs binding.`
+    );
+  }
+  const [targetKeyField] = Object.keys(rel.keyBinding);
+  const rawList = rawParentItem[refsBinding.from];
+  const elements = Array.isArray(rawList) ? rawList : [];
+  const queryKeys = [];
+  for (const element of elements) {
+    const refValue = element != null && typeof element === "object" ? element[refsBinding.key] : element;
+    if (refValue == null) continue;
+    queryKeys.push({ [targetKeyField]: refValue });
+  }
+  if (queryKeys.length === 0) {
+    return [];
+  }
+  const implicitKeys = getImplicitKeyFields(selectSpec.select, targetMeta);
+  const projectionExtras = options.updatable ? [...implicitKeys, "PK", "SK"] : implicitKeys;
+  const batchOps = planBatchGetForQueryKeys(
+    targetMeta,
+    queryKeys,
+    selectSpec.select,
+    projectionExtras.length > 0 ? projectionExtras : void 0
+  );
+  const executor = ClientManager.getExecutor();
+  const queryKeyToRaw = /* @__PURE__ */ new Map();
+  const mw = options.mw ?? NO_MIDDLEWARE;
+  const opPath = [...options.relationPath ?? [], rel.propertyName];
+  const opModel = mw.active ? ctxModelFor(rel.targetFactory()) : void 0;
+  for (const operation of batchOps) {
+    const items = mw.active ? await mw.runOp(
+      operation,
+      opPath,
+      opModel,
+      (op) => executor.batchGet(
+        op,
+        options.retry !== void 0 ? { retry: options.retry } : void 0
+      ).then((r) => r.items)
+    ) : (await executor.batchGet(
+      operation,
+      options.retry !== void 0 ? { retry: options.retry } : void 0
+    )).items;
+    for (const item of items) {
+      for (const queryKey of queryKeys) {
+        if (!matchesQueryKey(item, queryKey)) continue;
+        queryKeyToRaw.set(serializeQueryKey(queryKey), item);
+      }
+    }
+  }
+  const nestedRelations = detectRelationFields(selectSpec.select, targetMeta);
+  const seen = /* @__PURE__ */ new Set();
+  const orderedKeys = [];
+  for (const queryKey of queryKeys) {
+    const serialized = serializeQueryKey(queryKey);
+    if (seen.has(serialized)) continue;
+    seen.add(serialized);
+    orderedKeys.push(queryKey);
+  }
+  const resolved = orderedKeys.map(() => null);
+  await mapWithConcurrency(
+    orderedKeys,
+    options.plan?.plan.concurrency ?? RELATION_TRAVERSAL_CONCURRENCY,
+    async (queryKey, index) => {
+      const raw = queryKeyToRaw.get(serializeQueryKey(queryKey));
+      if (!raw) return;
+      const updatable = options.updatable ?? false;
+      let item = hydrate([raw], selectSpec.select, targetMeta, updatable)[0] ?? null;
+      if (item && nestedRelations.length > 0) {
+        item = await resolveRelations(
+          item,
+          raw,
+          selectSpec.select,
+          targetMeta,
+          options,
+          currentDepth + 1,
+          ownPath
+        );
+        if (item && updatable) attachHiddenKey(item, raw);
+      }
+      if (item && passesPostLoad(item, selectSpec, targetMeta)) {
+        resolved[index] = item;
+      }
+    }
+  );
+  return resolved.filter((item) => item !== null);
+}
 function passesPostLoad(item, spec, targetMeta) {
   if (spec.filter && !evaluateFilterClientSide(item, spec.filter, targetMeta)) {
     return false;
@@ -1270,6 +1344,21 @@ async function resolveRelations(parentItem, rawParentItem, select, metadata, opt
       };
       return;
     }
+    if (rel.type === "refs") {
+      const targetClass2 = rel.targetFactory();
+      const targetMeta2 = MetadataRegistry.get(targetClass2);
+      const items = await fetchRefsList(
+        rel,
+        rawParentItem,
+        selectSpec,
+        targetMeta2,
+        opts,
+        currentDepth,
+        ownPath
+      );
+      result[rel.propertyName] = { items, cursor: null };
+      return;
+    }
     const targetClass = rel.targetFactory();
     const targetMeta = MetadataRegistry.get(targetClass);
     const [resolvedItem] = await fetchBelongsToHasOneBatch(
@@ -1329,6 +1418,11 @@ async function executeQueryInner(modelClass, key, selectSpec, options, mw) {
   const normalized = normalizeTopLevelSelect(selectSpec);
   const select = normalized.select;
   const filter = normalized.filter;
+  validateInlineSnapshotSelect(
+    select,
+    metadata,
+    (rel) => MetadataRegistry.get(rel.targetFactory())
+  );
   const maxDepth = options?.maxDepth ?? 1;
   const relations = detectRelationFields(select, metadata);
   if (relations.length > 0) {
@@ -1346,8 +1440,13 @@ async function executeQueryInner(modelClass, key, selectSpec, options, mw) {
   });
   const operation = executionPlan.operations[0];
   const canParallelizeRelations = relations.length > 0 && relations.every(
-    (rel) => Object.values(rel.keyBinding).every(
-      (sourceField) => key[sourceField] != null
+    (rel) => (
+      // A `refs` relation (issue #197) resolves from the parent row's inline
+      // id-list (`refs.from`), which only exists on the FETCHED parent — never the
+      // input key — so it can never be dispatched before the parent read.
+      rel.type !== "refs" && Object.values(rel.keyBinding).every(
+        (sourceField) => key[sourceField] != null
+      )
     )
   );
   const retry = options?.retry;
@@ -1887,7 +1986,7 @@ function deriveOneConditionCheck(fragment, req) {
   return { entity: { name: targetName, modelClass: targetClass }, keyBinding };
 }
 function deriveEdgeWrites(fragment, edges, lifecycle) {
-  return edges.map((edge) => deriveOneEdgeWrite(fragment, edge, lifecycle));
+  return edges.flatMap((edge) => deriveOneEdgeWrite(fragment, edge, lifecycle));
 }
 function deriveOneEdgeWrite(fragment, edge, lifecycle) {
   const targetClass = edge.targetFactory();
@@ -1903,16 +2002,48 @@ function deriveOneEdgeWrite(fragment, edge, lifecycle) {
     );
   }
   const adjacencyClass = relation.targetFactory();
-  const items = deriveEdgeWriteItemsFor(
+  if (edge.inverse === void 0) {
+    const items = deriveEdgeWriteItemsFor(
+      adjacencyClass,
+      { targetFactory: edge.targetFactory, relationProperty: edge.relationProperty },
+      lifecycle
+    );
+    return [
+      {
+        entity: { name: adjacencyClass.name, modelClass: adjacencyClass },
+        relation: { target: targetClass.name, property: edge.relationProperty },
+        items
+      }
+    ];
+  }
+  const inverseAdjacency = edge.inverse.adjacencyFactory();
+  const allItems = deriveEdgeWriteItemsFor(
     adjacencyClass,
-    { targetFactory: edge.targetFactory, relationProperty: edge.relationProperty },
+    {
+      targetFactory: edge.targetFactory,
+      relationProperty: edge.relationProperty,
+      inverse: edge.inverse
+    },
     lifecycle
   );
-  return {
-    entity: { name: adjacencyClass.name, modelClass: adjacencyClass },
-    relation: { target: targetClass.name, property: edge.relationProperty },
-    items
-  };
+  const forwardItems = allItems.filter((it) => it.entity === adjacencyClass.name);
+  const inverseItems = allItems.filter((it) => it.entity === inverseAdjacency.name);
+  const inverseTargetClass = edge.inverse.targetFactory();
+  return [
+    {
+      entity: { name: adjacencyClass.name, modelClass: adjacencyClass },
+      relation: { target: targetClass.name, property: edge.relationProperty },
+      items: forwardItems
+    },
+    {
+      entity: { name: inverseAdjacency.name, modelClass: inverseAdjacency },
+      relation: {
+        target: inverseTargetClass.name,
+        property: edge.inverse.relationProperty
+      },
+      items: inverseItems
+    }
+  ];
 }
 function deriveUpdates(fragment, derive) {
   return derive.map((d) => deriveOneUpdate(fragment, d));
@@ -6669,6 +6800,11 @@ function buildRelationOperations(metadata, select, parentPath) {
     const targetClass = rel.targetFactory();
     const targetMeta = MetadataRegistry.get(targetClass);
     const childPath = `${parentPath}.${rel.propertyName}`;
+    if (rel.type === "refs") {
+      throw new Error(
+        `Relation '${rel.propertyName}' is a 'refs' relation (issue #197): its read fans an inline parent-row id-list ('${rel.refs?.from}[].${rel.refs?.key}') out into one BatchGet. The static operations spec / Python codegen cannot represent a parent-list key fan-out (operation key conditions bind a single scalar '{result.*}'), so a 'refs' relation is resolvable ONLY through the TS in-process runtime (Model.query). Remove '${rel.propertyName}' from selects that are compiled to operations.json / generated Python, or resolve it with a separate BatchGet in the generated-code consumer.`
+      );
+    }
     if (rel.type === "hasMany") {
       const limit = spec.limit ?? rel.options?.limit?.default ?? 20;
       ops.push(
@@ -6946,8 +7082,6 @@ export {
   SPEC_VERSION,
   MARKER_ROW_ENTITY,
   buildManifest,
-  detectRelationFields,
-  getImplicitKeyFields,
   buildProjection,
   compileFilterExpression,
   evaluateFilter,

package/dist/cli.js

@@ -3,11 +3,11 @@ import {
   buildBridgeBundle,
   buildManifest,
   buildOperations
-} from "./chunk-Y7XV5QL2.js";
+} from "./chunk-N5NQM3SO.js";
 import {
   MetadataRegistry,
   normalizeSelectSpec
-} from "./chunk-CCIVET5K.js";
+} from "./chunk-F2DI3GTI.js";
 import {
   createDefaultLinter
 } from "./chunk-PDUVTYC5.js";
@@ -744,6 +744,11 @@ function collectResultTypes(manifest, entity, select, typeName, out, seen) {
     const value = select[field];
     const relation = meta?.relations[field];
     if (relation) {
+      if (relation.type === "refs") {
+        throw new Error(
+          `Relation '${field}' on '${relation.target}' is a 'refs' relation (issue #197): it is resolvable only through the TS in-process runtime, not the Python runtime (its parent-list BatchGet fan-out has no static-spec / Python representation). Remove '${field}' from selects compiled to generated Python types.`
+        );
+      }
       const spec = normalizeSelectSpec(value);
       const childSelect = spec.select ?? {};
       const itemTypeName = `${typeName}${toPascalCase(field)}Item`;

package/dist/{from-change-DQK2Jm9R.d.ts → from-change-CFzBy7aU.d.ts}

@@ -1,4 +1,4 @@
-import { C as CdcEmulatorOptions, e as ChangeHandler, U as Unsubscribe, F as FaultSpec, g as ConcurrentRecomputeRef, c as ChangeEvent, E as EventLog, R as ReplayOptions, S as ShardId, V as ViewDefinition, m as EntityMetadata } from './maintenance-view-adapter-D5t9taTE.js';
+import { C as CdcEmulatorOptions, e as ChangeHandler, U as Unsubscribe, F as FaultSpec, g as ConcurrentRecomputeRef, c as ChangeEvent, E as EventLog, R as ReplayOptions, S as ShardId, V as ViewDefinition, m as EntityMetadata } from './maintenance-view-adapter-CFeasCKo.js';
 
 /**
  * CDC emulator (issue #72). Subscribes to the core write-capture seam

package/dist/{index-CtDBo8Se.d.ts → index-CtJbTrfB.d.ts}

@@ -1,5 +1,5 @@
-import { x as ParamDescriptor, y as EntityRef, z as ConditionInput, A as Param, M as ModelStatic, w as DDBModel, Q as QueryModelContract, G as QueryMethodSpec, H as CommandModelContract, I as CommandMethodSpec, J as ContractSpec, K as QuerySpec, L as CommandSpec, N as TransactionSpec, O as ContextSpec, X as DefinitionMap, Y as OperationsDocument, Z as AnyOperationDefinition, _ as Manifest, $ as BridgeBundle, a0 as ConditionSpec } from './maintenance-view-adapter-D5t9taTE.js';
-import { M as MetadataRegistry } from './registry-BD_5Rm5C.js';
+import { x as ParamDescriptor, y as EntityRef, z as ConditionInput, A as Param, M as ModelStatic, w as DDBModel, Q as QueryModelContract, G as QueryMethodSpec, H as CommandModelContract, I as CommandMethodSpec, J as ContractSpec, K as QuerySpec, L as CommandSpec, N as TransactionSpec, O as ContextSpec, X as DefinitionMap, Y as OperationsDocument, Z as AnyOperationDefinition, _ as Manifest, $ as BridgeBundle, a0 as ConditionSpec } from './maintenance-view-adapter-CFeasCKo.js';
+import { M as MetadataRegistry } from './registry-DbqmFyab.js';
 
 /**
  * Declarative transaction definition DSL (issue #46, Python-bridge Phase 4).