@optique/core 1.0.0-dev.1602 → 1.0.0-dev.1608

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/dist/constructs.cjs +194 -223
  2. package/dist/constructs.js +194 -223
  3. package/dist/dependency-runtime.cjs +328 -0
  4. package/dist/dependency-runtime.js +323 -0
  5. package/package.json +1 -1
package/dist/constructs.cjs CHANGED
@@ -1,6 +1,7 @@
1
1
  const require_annotations = require('./annotations.cjs');
2
2
  const require_message = require('./message.cjs');
3
3
  const require_dependency = require('./dependency.cjs');
4
+ const require_dependency_runtime = require('./dependency-runtime.cjs');
4
5
  const require_mode_dispatch = require('./mode-dispatch.cjs');
5
6
  const require_validate = require('./validate.cjs');
6
7
  const require_usage = require('./usage.cjs');
@@ -55,6 +56,34 @@ const inheritParentAnnotationsKey = Symbol.for("@optique/core/inheritParentAnnot
55
56
  */
56
57
  const fieldParsersKey = Symbol("fieldParsers");
57
58
  /**
59
+ * Extracts the actual {@link ValueParserResult} from a `complete()` return
60
+ * value, which may be a plain result or a `DependencySourceState` wrapper
61
+ * from the old protocol. This bridge helper allows the new runtime path
62
+ * to consume results from parsers that still return `DependencySourceState`.
63
+ * @internal
64
+ */
65
+ function unwrapCompleteResult(result) {
66
+ if (require_dependency.isDependencySourceState(result)) return result.result;
67
+ return result;
68
+ }
69
+ /**
70
+ * Prepares a field state for completion by wrapping `undefined` state
71
+ * with the parser's initial pending dependency state when needed.
72
+ *
73
+ * In the old protocol, when a parser has a `PendingDependencySourceState`
74
+ * as its initial state and the field state is `undefined` (option not
75
+ * provided), the construct wraps it as `[initialState]` so that
76
+ * `withDefault().complete()` can detect the pending dependency and
77
+ * return a `DependencySourceState` with the default value.
78
+ * @internal
79
+ */
80
+ function prepareStateForCompletion(fieldState, parser) {
81
+ if (fieldState !== void 0) return fieldState;
82
+ if (require_dependency.isPendingDependencySourceState(parser.initialState)) return [parser.initialState];
83
+ if (require_dependency.isWrappedDependencySource(parser)) return [parser[require_dependency.wrappedDependencySourceMarker]];
84
+ return fieldState;
85
+ }
86
+ /**
58
87
  * Returns the field state with parent annotations inherited, respecting
59
88
  * the parser's {@link inheritParentAnnotationsKey} flag. This is the
60
89
  * same logic as {@link createFieldStateGetter} inside `object()` but
@@ -689,12 +718,14 @@ function longestMatch(...args) {
689
718
  * @internal
690
719
  */
691
720
  function* suggestObjectSync(context, prefix, parserPairs) {
692
- const registry = context.dependencyRegistry ? context.dependencyRegistry.clone() : new require_dependency.DependencyRegistry();
693
- if (context.state && typeof context.state === "object") collectDependencies(context.state, registry);
694
- completeDependencySourceDefaults(context, parserPairs, registry, context.exec);
721
+ const runtime = require_dependency_runtime.createDependencyRuntimeContext(context.dependencyRegistry?.clone());
722
+ const nodes = require_dependency_runtime.buildRuntimeNodesFromPairs(parserPairs, context.state && typeof context.state === "object" ? context.state : {}, context.exec?.path);
723
+ require_dependency_runtime.collectExplicitSourceValues(nodes, runtime);
724
+ if (context.state && typeof context.state === "object") require_dependency_runtime.collectSourcesFromState(context.state, runtime);
725
+ completeDependencySourceDefaults(context, parserPairs, runtime.registry, context.exec);
695
726
  const contextWithRegistry = {
696
727
  ...context,
697
- dependencyRegistry: registry
728
+ dependencyRegistry: runtime.registry
698
729
  };
699
730
  if (context.buffer.length > 0) {
700
731
  const lastToken = context.buffer[context.buffer.length - 1];
@@ -723,12 +754,14 @@ function* suggestObjectSync(context, prefix, parserPairs) {
723
754
  * @internal
724
755
  */
725
756
  async function* suggestObjectAsync(context, prefix, parserPairs) {
726
- const registry = context.dependencyRegistry ? context.dependencyRegistry.clone() : new require_dependency.DependencyRegistry();
727
- if (context.state && typeof context.state === "object") collectDependencies(context.state, registry);
728
- await completeDependencySourceDefaultsAsync(context, parserPairs, registry, context.exec);
757
+ const runtime = require_dependency_runtime.createDependencyRuntimeContext(context.dependencyRegistry?.clone());
758
+ const nodes = require_dependency_runtime.buildRuntimeNodesFromPairs(parserPairs, context.state && typeof context.state === "object" ? context.state : {}, context.exec?.path);
759
+ require_dependency_runtime.collectExplicitSourceValues(nodes, runtime);
760
+ if (context.state && typeof context.state === "object") require_dependency_runtime.collectSourcesFromState(context.state, runtime);
761
+ await completeDependencySourceDefaultsAsync(context, parserPairs, runtime.registry, context.exec);
729
762
  const contextWithRegistry = {
730
763
  ...context,
731
- dependencyRegistry: registry
764
+ dependencyRegistry: runtime.registry
732
765
  };
733
766
  if (context.buffer.length > 0) {
734
767
  const lastToken = context.buffer[context.buffer.length - 1];
@@ -858,45 +891,71 @@ function collectChildFieldParsers(parsers) {
858
891
  * PendingDependencySourceState in arrays and wrappedDependencySourceMarker.
859
892
  *
860
893
  * The original state is NOT modified; only the registry is populated.
894
+ *
895
+ * Used by the new dependency runtime path as an old-protocol bridge:
896
+ * not all wrappers (e.g., `bindConfig`, `bindEnv`) compose
897
+ * `dependencyMetadata` yet, so metadata-based source collection alone
898
+ * cannot register all dependency values. This function fills the gap
899
+ * by inspecting old-protocol markers on the parsers.
861
900
  * @internal
862
901
  */
863
902
  function preCompleteAndRegisterDependencies(state, fieldParserPairs, registry, exec) {
903
+ const preCompleted = /* @__PURE__ */ new Map();
864
904
  for (const [field, fieldParser] of fieldParserPairs) {
865
905
  const fieldState = state[field];
866
- let completed;
867
- if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) completed = fieldParser.complete(fieldState, exec);
868
- else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) completed = fieldParser.complete([fieldParser.initialState], exec);
869
- else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
906
+ if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
907
+ const completed = fieldParser.complete(fieldState, exec);
908
+ preCompleted.set(field, completed);
909
+ if (require_dependency.isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
910
+ } else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
911
+ const completed = fieldParser.complete([fieldParser.initialState], exec);
912
+ preCompleted.set(field, completed);
913
+ if (require_dependency.isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
914
+ } else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
870
915
  const pendingState = fieldParser[require_dependency.wrappedDependencySourceMarker];
871
- completed = fieldParser.complete([pendingState], exec);
916
+ const completed = fieldParser.complete([pendingState], exec);
917
+ preCompleted.set(field, completed);
918
+ if (require_dependency.isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
872
919
  } else if (fieldState != null && !Array.isArray(fieldState) && !require_dependency.isDependencySourceState(fieldState) && (require_dependency.isWrappedDependencySource(fieldParser) || require_dependency.isPendingDependencySourceState(fieldParser.initialState))) {
873
920
  const annotatedFieldState = getAnnotatedFieldState(state, field, fieldParser);
874
- completed = fieldParser.complete(annotatedFieldState, exec);
875
- } else continue;
876
- const depState = wrapAsDependencySourceState(completed, fieldParser);
877
- if (depState) registerCompletedDependency(depState, registry);
921
+ const completed = fieldParser.complete(annotatedFieldState, exec);
922
+ preCompleted.set(field, completed);
923
+ const depState = wrapAsDependencySourceState(completed, fieldParser);
924
+ if (depState) registerCompletedDependency(depState, registry);
925
+ }
878
926
  }
927
+ return preCompleted;
879
928
  }
880
929
  /**
881
930
  * Async version of {@link preCompleteAndRegisterDependencies}.
882
931
  * @internal
883
932
  */
884
933
  async function preCompleteAndRegisterDependenciesAsync(state, fieldParserPairs, registry, exec) {
934
+ const preCompleted = /* @__PURE__ */ new Map();
885
935
  for (const [field, fieldParser] of fieldParserPairs) {
886
936
  const fieldState = state[field];
887
- let completed;
888
- if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) completed = await fieldParser.complete(fieldState, exec);
889
- else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) completed = await fieldParser.complete([fieldParser.initialState], exec);
890
- else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
937
+ if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
938
+ const completed = await fieldParser.complete(fieldState, exec);
939
+ preCompleted.set(field, completed);
940
+ if (require_dependency.isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
941
+ } else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
942
+ const completed = await fieldParser.complete([fieldParser.initialState], exec);
943
+ preCompleted.set(field, completed);
944
+ if (require_dependency.isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
945
+ } else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
891
946
  const pendingState = fieldParser[require_dependency.wrappedDependencySourceMarker];
892
- completed = await fieldParser.complete([pendingState], exec);
947
+ const completed = await fieldParser.complete([pendingState], exec);
948
+ preCompleted.set(field, completed);
949
+ if (require_dependency.isDependencySourceState(completed)) registerCompletedDependency(completed, registry);
893
950
  } else if (fieldState != null && !Array.isArray(fieldState) && !require_dependency.isDependencySourceState(fieldState) && (require_dependency.isWrappedDependencySource(fieldParser) || require_dependency.isPendingDependencySourceState(fieldParser.initialState))) {
894
951
  const annotatedFieldState = getAnnotatedFieldState(state, field, fieldParser);
895
- completed = await fieldParser.complete(annotatedFieldState, exec);
896
- } else continue;
897
- const depState = wrapAsDependencySourceState(completed, fieldParser);
898
- if (depState) registerCompletedDependency(depState, registry);
952
+ const completed = await fieldParser.complete(annotatedFieldState, exec);
953
+ preCompleted.set(field, completed);
954
+ const depState = wrapAsDependencySourceState(completed, fieldParser);
955
+ if (depState) registerCompletedDependency(depState, registry);
956
+ }
899
957
  }
958
+ return preCompleted;
900
959
  }
901
960
  /**
902
961
  * Recursively collects dependency values from DependencySourceState objects
@@ -1240,62 +1299,33 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
1240
1299
  },
1241
1300
  complete(state, exec) {
1242
1301
  return require_mode_dispatch.dispatchByMode(combinedMode, () => {
1243
- const preCompletedState = {};
1244
- const preCompletedKeys = /* @__PURE__ */ new Set();
1302
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
1303
+ const childExec = {
1304
+ ...exec,
1305
+ dependencyRuntime: runtime
1306
+ };
1307
+ const preCompleted = preCompleteAndRegisterDependencies(state, parserPairs, runtime.registry, childExec);
1245
1308
  const getFieldState = createFieldStateGetter(state);
1309
+ const annotatedState = {};
1246
1310
  for (const field of parserKeys) {
1247
1311
  const fieldKey = field;
1248
- const fieldState = state[fieldKey];
1249
1312
  const fieldParser = parsers[field];
1250
- if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
1251
- const completed = fieldParser.complete(fieldState, exec);
1252
- preCompletedState[fieldKey] = completed;
1253
- preCompletedKeys.add(fieldKey);
1254
- } else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
1255
- const completed = fieldParser.complete([fieldParser.initialState], exec);
1256
- preCompletedState[fieldKey] = completed;
1257
- preCompletedKeys.add(fieldKey);
1258
- } else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
1259
- const pendingState = fieldParser[require_dependency.wrappedDependencySourceMarker];
1260
- const completed = fieldParser.complete([pendingState], exec);
1261
- if (require_dependency.isDependencySourceState(completed)) {
1262
- preCompletedState[fieldKey] = completed;
1263
- preCompletedKeys.add(fieldKey);
1264
- } else preCompletedState[fieldKey] = fieldState;
1265
- } else if (fieldState != null && !Array.isArray(fieldState) && !require_dependency.isDependencySourceState(fieldState) && (require_dependency.isWrappedDependencySource(fieldParser) || require_dependency.isPendingDependencySourceState(fieldParser.initialState))) {
1266
- const annotatedFieldState = getFieldState(field, fieldParser);
1267
- const completed = fieldParser.complete(annotatedFieldState, exec);
1268
- const depState = wrapAsDependencySourceState(completed, fieldParser);
1269
- if (depState) {
1270
- preCompletedState[fieldKey] = depState;
1271
- preCompletedKeys.add(fieldKey);
1272
- } else preCompletedState[fieldKey] = annotatedFieldState;
1273
- } else preCompletedState[fieldKey] = getFieldState(field, fieldParser);
1313
+ annotatedState[fieldKey] = getFieldState(field, fieldParser);
1274
1314
  }
1275
- const resolvedState = resolveDeferredParseStates(preCompletedState);
1315
+ const resolvedFieldStates = require_dependency_runtime.resolveStateWithRuntime(annotatedState, runtime);
1276
1316
  const result = {};
1277
1317
  const deferredKeys = /* @__PURE__ */ new Map();
1278
1318
  let hasDeferred = false;
1279
- const getCompletionFieldState = createFieldStateGetter(state);
1280
1319
  for (const field of parserKeys) {
1281
1320
  const fieldKey = field;
1282
- const fieldResolvedState = resolvedState[fieldKey];
1283
1321
  const fieldParser = parsers[field];
1284
- if (require_dependency.isDependencySourceState(fieldResolvedState) && preCompletedKeys.has(fieldKey)) {
1285
- const depResult = fieldResolvedState.result;
1286
- if (depResult.success) {
1287
- result[fieldKey] = depResult.value;
1288
- if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(fieldKey, depResult.deferredKeys);
1289
- else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(fieldKey, null);
1290
- else hasDeferred = true;
1291
- } else return {
1292
- success: false,
1293
- error: depResult.error
1294
- };
1295
- continue;
1322
+ let valueResult;
1323
+ const preCompletedResult = preCompleted.get(fieldKey);
1324
+ if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
1325
+ else {
1326
+ const fieldState = resolvedFieldStates[fieldKey];
1327
+ valueResult = unwrapCompleteResult(fieldParser.complete(fieldState, childExec));
1296
1328
  }
1297
- const completionState = fieldResolvedState === void 0 ? getCompletionFieldState(field, fieldParser) : fieldResolvedState;
1298
- const valueResult = fieldParser.complete(completionState, exec);
1299
1329
  if (valueResult.success) {
1300
1330
  result[fieldKey] = valueResult.value;
1301
1331
  if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(fieldKey, valueResult.deferredKeys);
@@ -1316,62 +1346,33 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
1316
1346
  } : {}
1317
1347
  };
1318
1348
  }, async () => {
1319
- const preCompletedState = {};
1320
- const preCompletedKeys = /* @__PURE__ */ new Set();
1349
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
1350
+ const childExec = {
1351
+ ...exec,
1352
+ dependencyRuntime: runtime
1353
+ };
1354
+ const preCompleted = await preCompleteAndRegisterDependenciesAsync(state, parserPairs, runtime.registry, childExec);
1321
1355
  const getFieldState = createFieldStateGetter(state);
1356
+ const annotatedState = {};
1322
1357
  for (const field of parserKeys) {
1323
1358
  const fieldKey = field;
1324
- const fieldState = state[fieldKey];
1325
1359
  const fieldParser = parsers[field];
1326
- if (Array.isArray(fieldState) && fieldState.length === 1 && require_dependency.isPendingDependencySourceState(fieldState[0])) {
1327
- const completed = await fieldParser.complete(fieldState, exec);
1328
- preCompletedState[fieldKey] = completed;
1329
- preCompletedKeys.add(fieldKey);
1330
- } else if (fieldState === void 0 && require_dependency.isPendingDependencySourceState(fieldParser.initialState)) {
1331
- const completed = await fieldParser.complete([fieldParser.initialState], exec);
1332
- preCompletedState[fieldKey] = completed;
1333
- preCompletedKeys.add(fieldKey);
1334
- } else if (fieldState === void 0 && require_dependency.isWrappedDependencySource(fieldParser)) {
1335
- const pendingState = fieldParser[require_dependency.wrappedDependencySourceMarker];
1336
- const completed = await fieldParser.complete([pendingState], exec);
1337
- if (require_dependency.isDependencySourceState(completed)) {
1338
- preCompletedState[fieldKey] = completed;
1339
- preCompletedKeys.add(fieldKey);
1340
- } else preCompletedState[fieldKey] = fieldState;
1341
- } else if (fieldState != null && !Array.isArray(fieldState) && !require_dependency.isDependencySourceState(fieldState) && (require_dependency.isWrappedDependencySource(fieldParser) || require_dependency.isPendingDependencySourceState(fieldParser.initialState))) {
1342
- const annotatedFieldState = getFieldState(field, fieldParser);
1343
- const completed = await fieldParser.complete(annotatedFieldState, exec);
1344
- const depState = wrapAsDependencySourceState(completed, fieldParser);
1345
- if (depState) {
1346
- preCompletedState[fieldKey] = depState;
1347
- preCompletedKeys.add(fieldKey);
1348
- } else preCompletedState[fieldKey] = annotatedFieldState;
1349
- } else preCompletedState[fieldKey] = getFieldState(field, fieldParser);
1360
+ annotatedState[fieldKey] = getFieldState(field, fieldParser);
1350
1361
  }
1351
- const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
1362
+ const resolvedFieldStates = await require_dependency_runtime.resolveStateWithRuntimeAsync(annotatedState, runtime);
1352
1363
  const result = {};
1353
1364
  const deferredKeys = /* @__PURE__ */ new Map();
1354
1365
  let hasDeferred = false;
1355
- const getCompletionFieldState = createFieldStateGetter(state);
1356
1366
  for (const field of parserKeys) {
1357
1367
  const fieldKey = field;
1358
- const fieldResolvedState = resolvedState[fieldKey];
1359
1368
  const fieldParser = parsers[field];
1360
- if (require_dependency.isDependencySourceState(fieldResolvedState) && preCompletedKeys.has(fieldKey)) {
1361
- const depResult = fieldResolvedState.result;
1362
- if (depResult.success) {
1363
- result[fieldKey] = depResult.value;
1364
- if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(fieldKey, depResult.deferredKeys);
1365
- else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(fieldKey, null);
1366
- else hasDeferred = true;
1367
- } else return {
1368
- success: false,
1369
- error: depResult.error
1370
- };
1371
- continue;
1369
+ let valueResult;
1370
+ const preCompletedResult = preCompleted.get(fieldKey);
1371
+ if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
1372
+ else {
1373
+ const fieldState = resolvedFieldStates[fieldKey];
1374
+ valueResult = unwrapCompleteResult(await fieldParser.complete(fieldState, childExec));
1372
1375
  }
1373
- const completionState = fieldResolvedState === void 0 ? getCompletionFieldState(field, fieldParser) : fieldResolvedState;
1374
- const valueResult = await fieldParser.complete(completionState, exec);
1375
1376
  if (valueResult.success) {
1376
1377
  result[fieldKey] = valueResult.value;
1377
1378
  if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(fieldKey, valueResult.deferredKeys);
@@ -1635,48 +1636,27 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
1635
1636
  complete(state, exec) {
1636
1637
  return require_mode_dispatch.dispatchByMode(combinedMode, () => {
1637
1638
  const stateArray = state;
1638
- const preCompletedState = [];
1639
- for (let i = 0; i < syncParsers.length; i++) {
1640
- const elementState = stateArray[i];
1641
- const elementParser = syncParsers[i];
1642
- if (Array.isArray(elementState) && elementState.length === 1 && require_dependency.isPendingDependencySourceState(elementState[0])) {
1643
- const completed = elementParser.complete(elementState, exec);
1644
- preCompletedState[i] = completed;
1645
- } else if (elementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState)) {
1646
- const completed = elementParser.complete([elementParser.initialState], exec);
1647
- preCompletedState[i] = completed;
1648
- } else if (elementState === void 0 && require_dependency.isWrappedDependencySource(elementParser)) {
1649
- const pendingState = elementParser[require_dependency.wrappedDependencySourceMarker];
1650
- const completed = elementParser.complete([pendingState], exec);
1651
- preCompletedState[i] = completed;
1652
- } else preCompletedState[i] = elementState;
1653
- }
1654
- const resolvedState = resolveDeferredParseStates(preCompletedState);
1655
- const resolvedArray = resolvedState;
1639
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
1640
+ const childExec = {
1641
+ ...exec,
1642
+ dependencyRuntime: runtime
1643
+ };
1644
+ const tuplePairs = syncParsers.map((p, i) => [String(i), p]);
1645
+ const tupleState = Object.fromEntries(stateArray.map((s, i) => [String(i), s]));
1646
+ const preCompleted = preCompleteAndRegisterDependencies(tupleState, tuplePairs, runtime.registry, childExec);
1647
+ const resolvedArray = require_dependency_runtime.resolveStateWithRuntime(stateArray, runtime);
1656
1648
  const result = [];
1657
1649
  const deferredKeys = /* @__PURE__ */ new Map();
1658
1650
  let hasDeferred = false;
1659
1651
  for (let i = 0; i < syncParsers.length; i++) {
1660
- const elementResolvedState = resolvedArray[i];
1661
1652
  const elementParser = syncParsers[i];
1662
- const originalElementState = stateArray[i];
1663
- const wasPreCompletedCase1 = Array.isArray(originalElementState) && originalElementState.length === 1 && require_dependency.isPendingDependencySourceState(originalElementState[0]);
1664
- const wasPreCompletedCase2 = originalElementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState);
1665
- const wasPreCompletedCase3 = originalElementState === void 0 && require_dependency.isWrappedDependencySource(elementParser);
1666
- if (require_dependency.isDependencySourceState(elementResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
1667
- const depResult = elementResolvedState.result;
1668
- if (depResult.success) {
1669
- result[i] = depResult.value;
1670
- if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(i, depResult.deferredKeys);
1671
- else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(i, null);
1672
- else hasDeferred = true;
1673
- } else return {
1674
- success: false,
1675
- error: depResult.error
1676
- };
1677
- continue;
1653
+ let valueResult;
1654
+ const preCompletedResult = preCompleted.get(String(i));
1655
+ if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
1656
+ else {
1657
+ const elementState = prepareStateForCompletion(resolvedArray[i], elementParser);
1658
+ valueResult = unwrapCompleteResult(elementParser.complete(elementState, childExec));
1678
1659
  }
1679
- const valueResult = elementParser.complete(elementResolvedState, exec);
1680
1660
  if (valueResult.success) {
1681
1661
  result[i] = valueResult.value;
1682
1662
  if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(i, valueResult.deferredKeys);
@@ -1698,48 +1678,27 @@ function tuple(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
1698
1678
  };
1699
1679
  }, async () => {
1700
1680
  const stateArray = state;
1701
- const preCompletedState = [];
1702
- for (let i = 0; i < parsers.length; i++) {
1703
- const elementState = stateArray[i];
1704
- const elementParser = parsers[i];
1705
- if (Array.isArray(elementState) && elementState.length === 1 && require_dependency.isPendingDependencySourceState(elementState[0])) {
1706
- const completed = await elementParser.complete(elementState, exec);
1707
- preCompletedState[i] = completed;
1708
- } else if (elementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState)) {
1709
- const completed = await elementParser.complete([elementParser.initialState], exec);
1710
- preCompletedState[i] = completed;
1711
- } else if (elementState === void 0 && require_dependency.isWrappedDependencySource(elementParser)) {
1712
- const pendingState = elementParser[require_dependency.wrappedDependencySourceMarker];
1713
- const completed = await elementParser.complete([pendingState], exec);
1714
- preCompletedState[i] = completed;
1715
- } else preCompletedState[i] = elementState;
1716
- }
1717
- const resolvedState = await resolveDeferredParseStatesAsync(preCompletedState);
1718
- const resolvedArray = resolvedState;
1681
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
1682
+ const childExec = {
1683
+ ...exec,
1684
+ dependencyRuntime: runtime
1685
+ };
1686
+ const tuplePairs = parsers.map((p, i) => [String(i), p]);
1687
+ const tupleState = Object.fromEntries(stateArray.map((s, i) => [String(i), s]));
1688
+ const preCompleted = await preCompleteAndRegisterDependenciesAsync(tupleState, tuplePairs, runtime.registry, childExec);
1689
+ const resolvedArray = await require_dependency_runtime.resolveStateWithRuntimeAsync(stateArray, runtime);
1719
1690
  const result = [];
1720
1691
  const deferredKeys = /* @__PURE__ */ new Map();
1721
1692
  let hasDeferred = false;
1722
1693
  for (let i = 0; i < parsers.length; i++) {
1723
- const elementResolvedState = resolvedArray[i];
1724
1694
  const elementParser = parsers[i];
1725
- const originalElementState = stateArray[i];
1726
- const wasPreCompletedCase1 = Array.isArray(originalElementState) && originalElementState.length === 1 && require_dependency.isPendingDependencySourceState(originalElementState[0]);
1727
- const wasPreCompletedCase2 = originalElementState === void 0 && require_dependency.isPendingDependencySourceState(elementParser.initialState);
1728
- const wasPreCompletedCase3 = originalElementState === void 0 && require_dependency.isWrappedDependencySource(elementParser);
1729
- if (require_dependency.isDependencySourceState(elementResolvedState) && (wasPreCompletedCase1 || wasPreCompletedCase2 || wasPreCompletedCase3)) {
1730
- const depResult = elementResolvedState.result;
1731
- if (depResult.success) {
1732
- result[i] = depResult.value;
1733
- if (depResult.deferred) if (depResult.deferredKeys) deferredKeys.set(i, depResult.deferredKeys);
1734
- else if (depResult.value == null || typeof depResult.value !== "object") deferredKeys.set(i, null);
1735
- else hasDeferred = true;
1736
- } else return {
1737
- success: false,
1738
- error: depResult.error
1739
- };
1740
- continue;
1695
+ let valueResult;
1696
+ const preCompletedResult = preCompleted.get(String(i));
1697
+ if (preCompletedResult !== void 0) valueResult = unwrapCompleteResult(preCompletedResult);
1698
+ else {
1699
+ const elementState = prepareStateForCompletion(resolvedArray[i], elementParser);
1700
+ valueResult = unwrapCompleteResult(await elementParser.complete(elementState, childExec));
1741
1701
  }
1742
- const valueResult = await elementParser.complete(elementResolvedState, exec);
1743
1702
  if (valueResult.success) {
1744
1703
  result[i] = valueResult.value;
1745
1704
  if (valueResult.deferred) if (valueResult.deferredKeys) deferredKeys.set(i, valueResult.deferredKeys);
@@ -1999,20 +1958,25 @@ function merge(...args) {
1999
1958
  return parser.initialState;
2000
1959
  };
2001
1960
  if (!isAsync) {
1961
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
1962
+ const childExec = {
1963
+ ...exec,
1964
+ dependencyRuntime: runtime
1965
+ };
2002
1966
  const childFieldPairs = collectChildFieldParsers(syncParsers);
2003
- const registry = new require_dependency.DependencyRegistry();
2004
- preCompleteAndRegisterDependencies(state, childFieldPairs, registry, exec);
2005
- const resolvedState = resolveDeferredParseStates(state, registry);
1967
+ preCompleteAndRegisterDependencies(state, childFieldPairs, runtime.registry, childExec);
1968
+ const resolvedState = require_dependency_runtime.resolveStateWithRuntime(state, runtime);
2006
1969
  const object$1 = {};
2007
1970
  const deferredKeys = /* @__PURE__ */ new Map();
2008
1971
  let hasDeferred = false;
2009
1972
  for (let i = 0; i < syncParsers.length; i++) {
2010
1973
  const parser = syncParsers[i];
2011
1974
  const parserState = extractCompleteState(parser, resolvedState, i);
2012
- const result = parser.complete(parserState, exec);
1975
+ const result = unwrapCompleteResult(parser.complete(parserState, childExec));
2013
1976
  if (!result.success) return result;
2014
- for (const field in result.value) {
2015
- object$1[field] = result.value[field];
1977
+ const resultValue = result.value;
1978
+ for (const field in resultValue) {
1979
+ object$1[field] = resultValue[field];
2016
1980
  if (deferredKeys.has(field) && !(result.deferred && result.deferredKeys?.has(field))) deferredKeys.delete(field);
2017
1981
  }
2018
1982
  if (result.deferred && result.deferredKeys) for (const [key, value] of result.deferredKeys) deferredKeys.set(key, value);
@@ -2029,20 +1993,25 @@ function merge(...args) {
2029
1993
  };
2030
1994
  }
2031
1995
  return (async () => {
1996
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
1997
+ const childExec = {
1998
+ ...exec,
1999
+ dependencyRuntime: runtime
2000
+ };
2032
2001
  const childFieldPairs = collectChildFieldParsers(parsers);
2033
- const registry = new require_dependency.DependencyRegistry();
2034
- await preCompleteAndRegisterDependenciesAsync(state, childFieldPairs, registry, exec);
2035
- const resolvedState = await resolveDeferredParseStatesAsync(state, registry);
2002
+ await preCompleteAndRegisterDependenciesAsync(state, childFieldPairs, runtime.registry, childExec);
2003
+ const resolvedState = await require_dependency_runtime.resolveStateWithRuntimeAsync(state, runtime);
2036
2004
  const object$1 = {};
2037
2005
  const deferredKeys = /* @__PURE__ */ new Map();
2038
2006
  let hasDeferred = false;
2039
2007
  for (let i = 0; i < parsers.length; i++) {
2040
2008
  const parser = parsers[i];
2041
2009
  const parserState = extractCompleteState(parser, resolvedState, i);
2042
- const result = await parser.complete(parserState, exec);
2010
+ const result = unwrapCompleteResult(await parser.complete(parserState, childExec));
2043
2011
  if (!result.success) return result;
2044
- for (const field in result.value) {
2045
- object$1[field] = result.value[field];
2012
+ const resultValue = result.value;
2013
+ for (const field in resultValue) {
2014
+ object$1[field] = resultValue[field];
2046
2015
  if (deferredKeys.has(field) && !(result.deferred && result.deferredKeys?.has(field))) deferredKeys.delete(field);
2047
2016
  }
2048
2017
  if (result.deferred && result.deferredKeys) for (const [key, value] of result.deferredKeys) deferredKeys.set(key, value);
@@ -2077,15 +2046,13 @@ function merge(...args) {
2077
2046
  return p.initialState;
2078
2047
  };
2079
2048
  if (isAsync) return async function* () {
2080
- const registry$1 = context.dependencyRegistry ? context.dependencyRegistry.clone() : new require_dependency.DependencyRegistry();
2049
+ const runtime$1 = require_dependency_runtime.createDependencyRuntimeContext(context.dependencyRegistry?.clone());
2081
2050
  const childFieldPairs$1 = collectChildFieldParsers(parsers);
2082
- if (context.state && typeof context.state === "object") {
2083
- await preCompleteAndRegisterDependenciesAsync(context.state, childFieldPairs$1, registry$1, context.exec);
2084
- collectDependencies(context.state, registry$1);
2085
- } else await completeDependencySourceDefaultsAsync(context, childFieldPairs$1, registry$1, context.exec);
2051
+ if (context.state && typeof context.state === "object") require_dependency_runtime.collectSourcesFromState(context.state, runtime$1);
2052
+ await completeDependencySourceDefaultsAsync(context, childFieldPairs$1, runtime$1.registry, context.exec);
2086
2053
  const contextWithRegistry$1 = {
2087
2054
  ...context,
2088
- dependencyRegistry: registry$1
2055
+ dependencyRegistry: runtime$1.registry
2089
2056
  };
2090
2057
  const suggestions = [];
2091
2058
  for (let i = 0; i < parsers.length; i++) {
@@ -2100,15 +2067,13 @@ function merge(...args) {
2100
2067
  }
2101
2068
  yield* require_suggestion.deduplicateSuggestions(suggestions);
2102
2069
  }();
2103
- const registry = context.dependencyRegistry ? context.dependencyRegistry.clone() : new require_dependency.DependencyRegistry();
2070
+ const runtime = require_dependency_runtime.createDependencyRuntimeContext(context.dependencyRegistry?.clone());
2104
2071
  const childFieldPairs = collectChildFieldParsers(syncParsers);
2105
- if (context.state && typeof context.state === "object") {
2106
- preCompleteAndRegisterDependencies(context.state, childFieldPairs, registry, context.exec);
2107
- collectDependencies(context.state, registry);
2108
- } else completeDependencySourceDefaults(context, childFieldPairs, registry, context.exec);
2072
+ if (context.state && typeof context.state === "object") require_dependency_runtime.collectSourcesFromState(context.state, runtime);
2073
+ completeDependencySourceDefaults(context, childFieldPairs, runtime.registry, context.exec);
2109
2074
  const contextWithRegistry = {
2110
2075
  ...context,
2111
- dependencyRegistry: registry
2076
+ dependencyRegistry: runtime.registry
2112
2077
  };
2113
2078
  return function* () {
2114
2079
  const suggestions = [];
@@ -2195,12 +2160,12 @@ function merge(...args) {
2195
2160
  */
2196
2161
  function buildSuggestRegistry(preParsedContext) {
2197
2162
  const stateArray = preParsedContext.state;
2198
- const registry = preParsedContext.dependencyRegistry ? preParsedContext.dependencyRegistry.clone() : new require_dependency.DependencyRegistry();
2199
- if (stateArray && Array.isArray(stateArray)) collectDependencies(stateArray, registry);
2163
+ const runtime = require_dependency_runtime.createDependencyRuntimeContext(preParsedContext.dependencyRegistry?.clone());
2164
+ if (stateArray && Array.isArray(stateArray)) require_dependency_runtime.collectSourcesFromState(stateArray, runtime);
2200
2165
  return {
2201
2166
  context: {
2202
2167
  ...preParsedContext,
2203
- dependencyRegistry: registry
2168
+ dependencyRegistry: runtime.registry
2204
2169
  },
2205
2170
  stateArray
2206
2171
  };
@@ -2432,16 +2397,19 @@ function concat(...parsers) {
2432
2397
  };
2433
2398
  const completeSync = (state, exec) => {
2434
2399
  const stateArray = state;
2435
- const combinedState = {};
2436
- for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
2437
- const resolvedCombinedState = resolveDeferredParseStates(combinedState);
2400
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
2401
+ const childExec = {
2402
+ ...exec,
2403
+ dependencyRuntime: runtime
2404
+ };
2405
+ const resolvedArray = require_dependency_runtime.resolveStateWithRuntime(stateArray, runtime);
2438
2406
  const results = [];
2439
2407
  const deferredKeys = /* @__PURE__ */ new Map();
2440
2408
  let hasDeferred = false;
2441
2409
  for (let i = 0; i < syncParsers.length; i++) {
2442
2410
  const parser = syncParsers[i];
2443
- const parserState = resolvedCombinedState[i];
2444
- const result = parser.complete(parserState, exec);
2411
+ const parserState = prepareStateForCompletion(resolvedArray[i], parser);
2412
+ const result = unwrapCompleteResult(parser.complete(parserState, childExec));
2445
2413
  if (!result.success) return result;
2446
2414
  const baseIndex = results.length;
2447
2415
  if (Array.isArray(result.value)) {
@@ -2471,16 +2439,19 @@ function concat(...parsers) {
2471
2439
  };
2472
2440
  const completeAsync = async (state, exec) => {
2473
2441
  const stateArray = state;
2474
- const combinedState = {};
2475
- for (let i = 0; i < stateArray.length; i++) combinedState[i] = stateArray[i];
2476
- const resolvedCombinedState = await resolveDeferredParseStatesAsync(combinedState);
2442
+ const runtime = exec?.dependencyRuntime ?? require_dependency_runtime.createDependencyRuntimeContext(exec?.dependencyRegistry);
2443
+ const childExec = {
2444
+ ...exec,
2445
+ dependencyRuntime: runtime
2446
+ };
2447
+ const resolvedArray = await require_dependency_runtime.resolveStateWithRuntimeAsync(stateArray, runtime);
2477
2448
  const results = [];
2478
2449
  const deferredKeys = /* @__PURE__ */ new Map();
2479
2450
  let hasDeferred = false;
2480
2451
  for (let i = 0; i < parsers.length; i++) {
2481
2452
  const parser = parsers[i];
2482
- const parserState = resolvedCombinedState[i];
2483
- const result = await parser.complete(parserState, exec);
2453
+ const parserState = prepareStateForCompletion(resolvedArray[i], parser);
2454
+ const result = unwrapCompleteResult(await parser.complete(parserState, childExec));
2484
2455
  if (!result.success) return result;
2485
2456
  const baseIndex = results.length;
2486
2457
  if (Array.isArray(result.value)) {