@opetope/runtime 0.1.0

package/dist/module-generation.d.ts

@@ -0,0 +1,57 @@
+import { FeatureError } from '@opetope/core';
+import type { DeclarationId } from '@opetope/core';
+import type { ExactInput, IsAny } from '@opetope/core/internal';
+import type { CleanupFailurePolicy, ErrorReporter, ModuleDefinition, ModuleInstanceRef, ModuleRuntimeRecord, ModuleScopeRef } from './public-module.js';
+type SynchronousResult<Value> = [Value] extends [never] ? unknown : IsAny<Value> extends true ? never : [Extract<Value, PromiseLike<unknown>>] extends [never] ? unknown : never;
+type GenerationScopeValues<Runtime extends Readonly<Record<string, unknown>>> = string extends keyof Runtime ? never : {
+    readonly [Key in keyof Runtime as Runtime[Key] extends ModuleScopeRef<infer _Value, infer _Id> ? Key : never]: Runtime[Key] extends ModuleScopeRef<infer Value, infer _Id> ? Value : never;
+};
+type GenerationNotReadyFailure = {
+    readonly attachmentId: DeclarationId | undefined;
+    readonly cause: unknown;
+    readonly phase: 'open';
+    readonly reason: 'cancelled' | 'closed' | 'failed' | 'quarantined' | 'retired' | 'superseded' | 'threw';
+    readonly scope: string;
+    readonly stage: 'scope';
+} | {
+    readonly cause: unknown;
+    readonly phase: 'open';
+    readonly stage: 'prepare';
+};
+/**
+ * The handle a host holds for one opened feature. It is the kernel's instance ref, named with the author's word,
+ * Because a public member must not spell a kernel concept (D114).
+ */
+type FeatureInstanceHandle<Id extends string> = ModuleInstanceRef<Id>;
+interface FeatureInstance<Id extends string, Prepared = void> {
+    readonly close: () => Promise<void>;
+    readonly instance: FeatureInstanceHandle<Id>;
+    readonly ready: Promise<Prepared>;
+}
+interface GenerationBaseOptions<Runtime extends Readonly<Record<string, unknown>>, Values> {
+    readonly cleanupFailure?: CleanupFailurePolicy;
+    readonly reporter: ErrorReporter;
+    readonly scopes: ExactInput<Values, GenerationScopeValues<Runtime>>;
+}
+interface GenerationPreparedOptions<Id extends string, Runtime extends ModuleRuntimeRecord<Id>, Values, Prepared> extends GenerationBaseOptions<Runtime, Values> {
+    readonly prepare: (instance: ModuleInstanceRef<Id>) => Prepared;
+}
+type GenerationUnpreparedOptions<Runtime extends Readonly<Record<string, unknown>>, Values> = GenerationBaseOptions<Runtime, Values> & {
+    readonly prepare?: never;
+};
+/**
+ * The top line names what failed and why. The cause used to sit two levels down, so an author read «preparation
+ * Failed» and had to walk `failure.cause` by hand to find the key and the sentence.
+ */
+declare function notReadyGeneration(moduleId: DeclarationId, failure: GenerationNotReadyFailure): FeatureError;
+/** Idempotent by construction: `retire()` of an already retiring instance returns the same record (D189). */
+declare function fenceFeatureGeneration(generation: object): void;
+/** D186: a lazy header hands out its own object, so it registers the fence that reaches the instance it opens. */
+declare function registerFeatureGenerationFence(generation: object, fence: () => void): void;
+/** A feature with contributions hands out a wrapper, and the fence follows the object the application holds. */
+declare function carryFeatureGenerationFence(from: object, to: object): void;
+declare function quarantinedGeneration(moduleId: DeclarationId, failures: readonly unknown[], cause: unknown, retryOperation: () => Promise<void>): FeatureError;
+declare function openFeature<const Id extends string, const Runtime extends ModuleRuntimeRecord<Id>, const Values extends GenerationScopeValues<Runtime>, const Options extends GenerationUnpreparedOptions<Runtime, Values>>(definition: ModuleDefinition<Id, Runtime>, options: ExactInput<Options, GenerationUnpreparedOptions<Runtime, Values>>): FeatureInstance<Id>;
+declare function openFeature<const Id extends string, const Runtime extends ModuleRuntimeRecord<Id>, const Values extends GenerationScopeValues<Runtime>, Prepared, const Options extends GenerationPreparedOptions<Id, Runtime, Values, Prepared>>(definition: ModuleDefinition<Id, Runtime>, options: ExactInput<Options, GenerationPreparedOptions<Id, Runtime, Values, Prepared>> & SynchronousResult<Prepared>): FeatureInstance<Id, Prepared>;
+export { carryFeatureGenerationFence, fenceFeatureGeneration, notReadyGeneration, openFeature, quarantinedGeneration, registerFeatureGenerationFence, };
+export type { FeatureInstance };

package/dist/module-generation.js

@@ -0,0 +1,2 @@
+import{FeatureError as E}from"@opetope/core";import{hasOwn as l}from"@opetope/core/internal";import{assertPlainRecord as T}from"./feature-record.js";import{reportRuntimeFailure as j}from"./runtime-error-reporting.js";import{instantiateModule as C}from"./public-module-instance.js";import{getModuleScopeEntries as P}from"./public-module-definition.js";import{projectModuleCleanupFailures as z}from"./public-module-retirement-diagnostics.js";const x=Object.freeze([]),I=new Set(["cleanupFailure","prepare","reporter","scopes"]);function U(e){return e instanceof Error?` ${e.message}`:typeof e=="string"&&e.length>0?` ${e}`:""}function V(e){return e.stage==="prepare"?"preparation failed":e.attachmentId===void 0?`scope ${e.scope} failed to open`:`attachment ${e.attachmentId.slice(e.attachmentId.lastIndexOf("/")+1)} failed to open`}function k(e,n){const t=V(n);return new E("not-ready",e,{failure:n,message:`Feature ${e} instance ${t}.${U(n.cause)}`})}const h=new WeakMap;function A(e){var n;(n=h.get(e))==null||n()}function W(e,n){h.set(e,n)}function B(e,n){const t=h.get(e);t!==void 0&&h.set(n,t)}function D(e){let n,t=e;const i=()=>{t=()=>n??Promise.resolve()};return()=>{const a=t();return n!==void 0||(n=a,a.then(i,i)),a}}function $(e,n,t,i){return new E("quarantined",e,{cause:t,failures:n,retryCleanup:D(i)})}function H(e,n){T(n,"openFeature scopes");const t=P(e),i=new Set(t.map(r=>r.key)),a=Reflect.ownKeys(n);for(const r of a)if(typeof r!="string"||!i.has(r))throw new TypeError(`Unknown openFeature scope ${String(r)}.`);if(a.length!==t.length){const r=t.find(y=>!l(n,y.key));throw new TypeError(`openFeature requires scope ${(r==null?void 0:r.key)??"<unknown>"}.`)}return t.map(r=>({key:r.key,scope:r.scope,value:Reflect.get(n,r.key)}))}function J(e){for(const n of Reflect.ownKeys(e))if(!I.has(n))throw new TypeError(`Unknown openFeature option ${String(n)}.`)}function L(e){if(!l(e,"scopes"))throw new TypeError("openFeature requires own scopes.");if(!l(e,"reporter"))throw new TypeError("openFeature requires own reporter.")}function N(e){const n=l(e,"cleanupFailure")?Reflect.get(e,"cleanupFailure"):"report";if(n!=="report"&&n!=="quarantine")throw new TypeError('openFeature cleanupFailure must be "report" or "quarantine".');return n}function Q(e){const n=l(e,"prepare")?Reflect.get(e,"prepare"):void 0;if(n!==void 0&&typeof n!="function")throw new TypeError("openFeature prepare must be a function.");return n}function X(e){const n=Reflect.get(e,"reporter");if(typeof n!="function")throw new TypeError("openFeature reporter must be a function.");return n}function Y(e,n){return T(n,"openFeature options"),J(n),L(n),{cleanupFailure:N(n),prepare:Q(n),reporter:X(n),scopes:H(e,Reflect.get(n,"scopes"))}}function Z(e){return(typeof e!="object"||e===null)&&typeof e!="function"?!1:typeof Reflect.get(e,"then")=="function"}function _(e,n,t){return k(e,Object.freeze({attachmentId:void 0,cause:t,phase:"open",reason:"threw",scope:n.key,stage:"scope"}))}function v(e,n,t){if(t.kind!=="ready")return k(e,Object.freeze({attachmentId:t.kind==="not-ready"?t.attachmentId:void 0,cause:t.kind==="not-ready"?t.cause:void 0,phase:"open",reason:t.kind==="not-ready"?t.reason:"retired",scope:n.key,stage:"scope"}))}async function ee(e,n,t){try{const i=await n.scope(t.scope).open(t.value);return v(e,t,i)}catch(i){return _(e,t,i)}}function ne(e,n){Promise.resolve(e).catch(t=>j(t,n))}function te(e,n,t,i,a){let r,y=!1,R=!1,w;const G=(o,u)=>{let s;const p=z(n,o.failures);return $(e,p,u,()=>{const g=n.retire();if(s!==void 0)return s;const f=g.retry().then(O=>{if(O.kind==="quarantined")throw G(O,u)});return s=f,w=f,f})},K=()=>{R=!0,n.retire()},d=o=>{const u=n.retire();if(w!==void 0)return w;const s=u.drain().then(p=>{if(p.kind==="quarantined")throw G(p,o)});return w=s,s},F=()=>{if(R)return r??(r=new E("retired",e))},q=()=>{a=x};let c,m;try{if(c=t==null?void 0:t(n),Z(c)){const o=c;throw c=void 0,ne(o,i),new TypeError("openFeature prepare must return synchronously.")}}catch(o){m=k(e,Object.freeze({cause:o,phase:"open",stage:"prepare"}))}finally{t=void 0}let S=m===void 0?(async()=>{for(const s of a){const p=F();if(p!==void 0)throw await d(p),p;const g=await ee(e,n,s);if(g!==void 0){const f=F()??g;throw await d(f),f}}const o=F();if(o!==void 0)throw await d(o),o;const u=c;return c=void 0,y=!0,u})():d(m).then(()=>{throw m});const M=S.then(o=>(q(),o),o=>{throw c=void 0,q(),o});S=void 0;const b={close:()=>(R=!0,d(y?void 0:F())),instance:n,ready:M};return h.set(b,K),b}function re(e,n){const t=Y(e,n),i=C(e,{cleanupFailure:t.cleanupFailure,reporter:t.reporter});return te(e.id,i,t.prepare,t.reporter,t.scopes)}export{B as carryFeatureGenerationFence,A as fenceFeatureGeneration,k as notReadyGeneration,re as openFeature,$ as quarantinedGeneration,W as registerFeatureGenerationFence};
+//# sourceMappingURL=module-generation.js.map

package/dist/module-generation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-generation.js","sources":["../src/module-generation.ts"],"sourcesContent":["import { FeatureError } from '@opetope/core';\nimport type { DeclarationId } from '@opetope/core';\nimport type { ExactInput, IsAny } from '@opetope/core/internal';\nimport { hasOwn } from '@opetope/core/internal';\n\nimport { assertPlainRecord } from './feature-record';\nimport { getModuleScopeEntries, instantiateModule, projectModuleCleanupFailures } from './public-module';\nimport type {\n  CleanupFailurePolicy,\n  ErrorReporter,\n  ModuleDefinition,\n  ModuleDrainOutcome,\n  ModuleInstance,\n  ModuleInstanceRef,\n  ModuleRuntimeRecord,\n  ModuleScopeOpenOutcome,\n  ModuleScopeRef,\n} from './public-module';\nimport { reportRuntimeFailure } from './runtime-error-reporting';\n\ntype SynchronousResult<Value> = [Value] extends [never]\n  ? unknown\n  : IsAny<Value> extends true\n    ? never\n    : [Extract<Value, PromiseLike<unknown>>] extends [never]\n      ? unknown\n      : never;\n\ntype GenerationScopeValues<Runtime extends Readonly<Record<string, unknown>>> = string extends keyof Runtime\n  ? never\n  : {\n      readonly [\n        Key in keyof Runtime as Runtime[Key] extends ModuleScopeRef<infer _Value, infer _Id> ? Key : never\n      ]: Runtime[Key] extends ModuleScopeRef<infer Value, infer _Id> ? Value : never;\n    };\n\ntype GenerationNotReadyFailure =\n  | {\n      readonly attachmentId: DeclarationId | undefined;\n      readonly cause: unknown;\n      readonly phase: 'open';\n      readonly reason: 'cancelled' | 'closed' | 'failed' | 'quarantined' | 'retired' | 'superseded' | 'threw';\n      readonly scope: string;\n      readonly stage: 'scope';\n    }\n  | {\n      readonly cause: unknown;\n      readonly phase: 'open';\n      readonly stage: 'prepare';\n    };\n\n/**\n * The handle a host holds for one opened feature. It is the kernel's instance ref, named with the author's word,\n * Because a public member must not spell a kernel concept (D114).\n */\ntype FeatureInstanceHandle<Id extends string> = ModuleInstanceRef<Id>;\n\ninterface FeatureInstance<Id extends string, Prepared = void> {\n  readonly close: () => Promise<void>;\n  readonly instance: FeatureInstanceHandle<Id>;\n  readonly ready: Promise<Prepared>;\n}\n\ninterface GenerationBaseOptions<Runtime extends Readonly<Record<string, unknown>>, Values> {\n  readonly cleanupFailure?: CleanupFailurePolicy;\n  readonly reporter: ErrorReporter;\n  readonly scopes: ExactInput<Values, GenerationScopeValues<Runtime>>;\n}\n\ninterface GenerationPreparedOptions<\n  Id extends string,\n  Runtime extends ModuleRuntimeRecord<Id>,\n  Values,\n  Prepared,\n> extends GenerationBaseOptions<Runtime, Values> {\n  readonly prepare: (instance: ModuleInstanceRef<Id>) => Prepared;\n}\n\ntype GenerationUnpreparedOptions<Runtime extends Readonly<Record<string, unknown>>, Values> = GenerationBaseOptions<\n  Runtime,\n  Values\n> & {\n  readonly prepare?: never;\n};\n\ntype ScopeValueEntry = {\n  readonly key: string;\n  readonly scope: ModuleScopeRef<unknown>;\n  readonly value: unknown;\n};\n\nconst emptyScopeValueEntries: readonly ScopeValueEntry[] = Object.freeze([]);\n\ntype GenerationOptionsSnapshot<Id extends string> = {\n  readonly cleanupFailure: CleanupFailurePolicy;\n  readonly prepare: ((instance: ModuleInstanceRef<Id>) => unknown) | undefined;\n  readonly reporter: ErrorReporter;\n  readonly scopes: readonly ScopeValueEntry[];\n};\n\nconst moduleGenerationOptionKeys = new Set<PropertyKey>(['cleanupFailure', 'prepare', 'reporter', 'scopes']);\n\n/** What a cause can tell an author without printing a stack: its own sentence, or nothing at all. */\nfunction causeSentence(cause: unknown): string {\n  if (cause instanceof Error) return ` ${cause.message}`;\n\n  return typeof cause === 'string' && cause.length > 0 ? ` ${cause}` : '';\n}\n\n/** An attachment names itself, so the top line says `attachment polling`, not the hidden scope it was lowered into. */\nfunction failedSubject(failure: GenerationNotReadyFailure): string {\n  if (failure.stage === 'prepare') return 'preparation failed';\n\n  if (failure.attachmentId === undefined) return `scope ${failure.scope} failed to open`;\n\n  return `attachment ${failure.attachmentId.slice(failure.attachmentId.lastIndexOf('/') + 1)} failed to open`;\n}\n\n/**\n * The top line names what failed and why. The cause used to sit two levels down, so an author read «preparation\n * Failed» and had to walk `failure.cause` by hand to find the key and the sentence.\n */\nfunction notReadyGeneration(moduleId: DeclarationId, failure: GenerationNotReadyFailure): FeatureError {\n  const where = failedSubject(failure);\n\n  return new FeatureError('not-ready', moduleId, {\n    failure,\n    message: `Feature ${moduleId} instance ${where}.${causeSentence(failure.cause)}`,\n  });\n}\n\n/** The reentrancy guard the quarantine class used to own: one pending retry per error instance. */\n/** The fence of a generation, kept off its public shape: only the application layer above may stop admission. */\nconst generationFences = new WeakMap<object, () => void>();\n\n/** Idempotent by construction: `retire()` of an already retiring instance returns the same record (D189). */\nfunction fenceFeatureGeneration(generation: object): void {\n  generationFences.get(generation)?.();\n}\n\n/** D186: a lazy header hands out its own object, so it registers the fence that reaches the instance it opens. */\nfunction registerFeatureGenerationFence(generation: object, fence: () => void): void {\n  generationFences.set(generation, fence);\n}\n\n/** A feature with contributions hands out a wrapper, and the fence follows the object the application holds. */\nfunction carryFeatureGenerationFence(from: object, to: object): void {\n  const fence = generationFences.get(from);\n\n  if (fence !== undefined) generationFences.set(to, fence);\n}\n\nfunction quarantineRetry(retryOperation: () => Promise<void>): () => Promise<void> {\n  let pending: Promise<void> | undefined;\n  let operation = retryOperation;\n  const release = (): void => {\n    operation = () => pending ?? Promise.resolve();\n  };\n\n  return () => {\n    // Invoke first so a retry callback cannot bypass the guard by receiving its own pending promise.\n    const retry = operation();\n\n    if (pending !== undefined) return retry;\n\n    pending = retry;\n    void retry.then(release, release);\n\n    return retry;\n  };\n}\n\nfunction quarantinedGeneration(\n  moduleId: DeclarationId,\n  failures: readonly unknown[],\n  cause: unknown,\n  retryOperation: () => Promise<void>,\n): FeatureError {\n  return new FeatureError('quarantined', moduleId, {\n    cause,\n    failures,\n    retryCleanup: quarantineRetry(retryOperation),\n  });\n}\n\nfunction snapshotScopeValues<Id extends string, Runtime extends ModuleRuntimeRecord<Id>>(\n  definition: ModuleDefinition<Id, Runtime>,\n  value: unknown,\n): readonly ScopeValueEntry[] {\n  assertPlainRecord(value, 'openFeature scopes');\n  const expected = getModuleScopeEntries(definition);\n  const expectedKeys = new Set(expected.map(entry => entry.key));\n  const propertyKeys = Reflect.ownKeys(value);\n\n  for (const propertyKey of propertyKeys) {\n    if (typeof propertyKey !== 'string' || !expectedKeys.has(propertyKey)) {\n      throw new TypeError(`Unknown openFeature scope ${String(propertyKey)}.`);\n    }\n  }\n\n  if (propertyKeys.length !== expected.length) {\n    const missing = expected.find(entry => !hasOwn(value, entry.key));\n\n    throw new TypeError(`openFeature requires scope ${missing?.key ?? '<unknown>'}.`);\n  }\n\n  return expected.map(entry => ({\n    key: entry.key,\n    scope: entry.scope as unknown as ModuleScopeRef<unknown>,\n    value: Reflect.get(value, entry.key),\n  }));\n}\n\nfunction assertKnownModuleGenerationOptionKeys(value: object): void {\n  for (const propertyKey of Reflect.ownKeys(value)) {\n    if (!moduleGenerationOptionKeys.has(propertyKey)) {\n      throw new TypeError(`Unknown openFeature option ${String(propertyKey)}.`);\n    }\n  }\n}\n\nfunction assertRequiredModuleGenerationOptions(value: object): void {\n  if (!hasOwn(value, 'scopes')) throw new TypeError('openFeature requires own scopes.');\n\n  if (!hasOwn(value, 'reporter')) throw new TypeError('openFeature requires own reporter.');\n}\n\nfunction snapshotGenerationCleanupFailure(value: object): CleanupFailurePolicy {\n  const cleanupFailure: unknown = hasOwn(value, 'cleanupFailure') ? Reflect.get(value, 'cleanupFailure') : 'report';\n\n  if (cleanupFailure !== 'report' && cleanupFailure !== 'quarantine') {\n    throw new TypeError('openFeature cleanupFailure must be \"report\" or \"quarantine\".');\n  }\n\n  return cleanupFailure;\n}\n\nfunction snapshotGenerationPrepare<Id extends string>(\n  value: object,\n): ((instance: ModuleInstanceRef<Id>) => unknown) | undefined {\n  const prepare: unknown = hasOwn(value, 'prepare') ? Reflect.get(value, 'prepare') : undefined;\n\n  if (prepare !== undefined && typeof prepare !== 'function') {\n    throw new TypeError('openFeature prepare must be a function.');\n  }\n\n  return prepare as ((instance: ModuleInstanceRef<Id>) => unknown) | undefined;\n}\n\nfunction snapshotGenerationReporter(value: object): ErrorReporter {\n  const reporter: unknown = Reflect.get(value, 'reporter');\n\n  if (typeof reporter !== 'function') throw new TypeError('openFeature reporter must be a function.');\n\n  return reporter as ErrorReporter;\n}\n\nfunction snapshotModuleGenerationOptions<Id extends string, Runtime extends ModuleRuntimeRecord<Id>>(\n  definition: ModuleDefinition<Id, Runtime>,\n  value: unknown,\n): GenerationOptionsSnapshot<Id> {\n  assertPlainRecord(value, 'openFeature options');\n  assertKnownModuleGenerationOptionKeys(value);\n  assertRequiredModuleGenerationOptions(value);\n\n  return {\n    cleanupFailure: snapshotGenerationCleanupFailure(value),\n    prepare: snapshotGenerationPrepare<Id>(value),\n    reporter: snapshotGenerationReporter(value),\n    scopes: snapshotScopeValues(definition, Reflect.get(value, 'scopes')),\n  };\n}\n\nfunction isThenable(value: unknown): boolean {\n  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') return false;\n\n  return typeof Reflect.get(value, 'then') === 'function';\n}\n\nfunction failedScopeCall(moduleId: DeclarationId, entry: ScopeValueEntry, cause: unknown): FeatureError {\n  return notReadyGeneration(\n    moduleId,\n    Object.freeze({\n      attachmentId: undefined,\n      cause,\n      phase: 'open' as const,\n      reason: 'threw' as const,\n      scope: entry.key,\n      stage: 'scope' as const,\n    }),\n  );\n}\n\nfunction failedScopeOutcome(\n  moduleId: DeclarationId,\n  entry: ScopeValueEntry,\n  outcome: ModuleScopeOpenOutcome,\n): FeatureError | undefined {\n  if (outcome.kind === 'ready') return undefined;\n\n  return notReadyGeneration(\n    moduleId,\n    Object.freeze({\n      attachmentId: outcome.kind === 'not-ready' ? outcome.attachmentId : undefined,\n      cause: outcome.kind === 'not-ready' ? outcome.cause : undefined,\n      phase: 'open' as const,\n      reason: outcome.kind === 'not-ready' ? outcome.reason : ('retired' as const),\n      scope: entry.key,\n      stage: 'scope' as const,\n    }),\n  );\n}\n\nasync function openGenerationScope<Id extends string>(\n  moduleId: DeclarationId,\n  instance: ModuleInstance<Id>,\n  entry: ScopeValueEntry,\n): Promise<FeatureError | undefined> {\n  try {\n    const outcome = await instance.scope(entry.scope as unknown as ModuleScopeRef<unknown, Id>).open(entry.value);\n\n    return failedScopeOutcome(moduleId, entry, outcome);\n  } catch (cause) {\n    return failedScopeCall(moduleId, entry, cause);\n  }\n}\n\nfunction superviseInvalidPreparation(result: unknown, reporter: ErrorReporter): void {\n  void Promise.resolve(result).catch((error: unknown) => reportRuntimeFailure(error, reporter));\n}\n\nfunction createModuleGenerationController<Id extends string>(\n  moduleId: DeclarationId,\n  instance: ModuleInstance<Id>,\n  prepare: ((instance: ModuleInstanceRef<Id>) => unknown) | undefined,\n  reporter: ErrorReporter,\n  scopeEntries: readonly ScopeValueEntry[],\n): FeatureInstance<Id, unknown> {\n  let inactiveReason: FeatureError | undefined;\n  let openingCommitted = false;\n  let retirementRequested = false;\n  let retirementAttempt: Promise<void> | undefined;\n\n  const quarantineError = (\n    outcome: Extract<ModuleDrainOutcome, { readonly kind: 'quarantined' }>,\n    cause: unknown,\n  ): FeatureError => {\n    let retry: Promise<void> | undefined;\n    const failures = projectModuleCleanupFailures(instance, outcome.failures);\n\n    return quarantinedGeneration(moduleId, failures, cause, () => {\n      const handle = instance.retire();\n\n      if (retry !== undefined) return retry;\n\n      const attempt = handle.retry().then(nextOutcome => {\n        if (nextOutcome.kind === 'quarantined') throw quarantineError(nextOutcome, cause);\n      });\n      retry = attempt;\n      retirementAttempt = attempt;\n\n      return attempt;\n    });\n  };\n\n  /**\n   * Admission stops here and nothing physical starts: the instance is fenced, so a call saved by someone else can no\n   * longer begin a body, while the ordered drain of the layer above still decides when cleanup runs (D189).\n   */\n  const fence = (): void => {\n    retirementRequested = true;\n    instance.retire();\n  };\n\n  const startRetirement = (cause: unknown): Promise<void> => {\n    const handle = instance.retire();\n\n    if (retirementAttempt !== undefined) return retirementAttempt;\n\n    const attempt = handle.drain().then(outcome => {\n      if (outcome.kind === 'quarantined') throw quarantineError(outcome, cause);\n    });\n    retirementAttempt = attempt;\n\n    return attempt;\n  };\n\n  const cancellationReason = (): FeatureError | undefined => {\n    if (!retirementRequested) return undefined;\n\n    return (inactiveReason ??= new FeatureError('retired', moduleId));\n  };\n\n  const releaseScopeEntries = (): void => {\n    scopeEntries = emptyScopeValueEntries;\n  };\n\n  let prepared: unknown;\n  let preparationFailure: FeatureError | undefined;\n\n  try {\n    prepared = prepare?.(instance);\n\n    if (isThenable(prepared)) {\n      const asynchronousPreparation = prepared;\n      prepared = undefined;\n      superviseInvalidPreparation(asynchronousPreparation, reporter);\n\n      throw new TypeError('openFeature prepare must return synchronously.');\n    }\n  } catch (cause) {\n    preparationFailure = notReadyGeneration(\n      moduleId,\n      Object.freeze({ cause, phase: 'open' as const, stage: 'prepare' as const }),\n    );\n  } finally {\n    prepare = undefined;\n  }\n\n  let opening: Promise<unknown> | undefined =\n    preparationFailure === undefined\n      ? (async (): Promise<unknown> => {\n          for (const entry of scopeEntries) {\n            const inactive = cancellationReason();\n\n            if (inactive !== undefined) {\n              await startRetirement(inactive);\n\n              throw inactive;\n            }\n\n            const failure = await openGenerationScope(moduleId, instance, entry);\n\n            if (failure !== undefined) {\n              const reason = cancellationReason() ?? failure;\n\n              await startRetirement(reason);\n\n              throw reason;\n            }\n          }\n\n          const inactive = cancellationReason();\n\n          if (inactive !== undefined) {\n            await startRetirement(inactive);\n\n            throw inactive;\n          }\n\n          const result = prepared;\n          prepared = undefined;\n          openingCommitted = true;\n\n          return result;\n        })()\n      : startRetirement(preparationFailure).then(() => {\n          throw preparationFailure;\n        });\n  const ready = opening.then(\n    value => {\n      releaseScopeEntries();\n\n      return value;\n    },\n    (cause: unknown) => {\n      prepared = undefined;\n      releaseScopeEntries();\n\n      throw cause;\n    },\n  );\n  opening = undefined;\n  const generation = {\n    close: (): Promise<void> => {\n      retirementRequested = true;\n\n      return startRetirement(openingCommitted ? undefined : cancellationReason());\n    },\n    instance,\n    ready,\n  };\n  generationFences.set(generation, fence);\n\n  return generation;\n}\n\nfunction openFeature<\n  const Id extends string,\n  const Runtime extends ModuleRuntimeRecord<Id>,\n  const Values extends GenerationScopeValues<Runtime>,\n  const Options extends GenerationUnpreparedOptions<Runtime, Values>,\n>(\n  definition: ModuleDefinition<Id, Runtime>,\n  options: ExactInput<Options, GenerationUnpreparedOptions<Runtime, Values>>,\n): FeatureInstance<Id>;\nfunction openFeature<\n  const Id extends string,\n  const Runtime extends ModuleRuntimeRecord<Id>,\n  const Values extends GenerationScopeValues<Runtime>,\n  Prepared,\n  const Options extends GenerationPreparedOptions<Id, Runtime, Values, Prepared>,\n>(\n  definition: ModuleDefinition<Id, Runtime>,\n  options: ExactInput<Options, GenerationPreparedOptions<Id, Runtime, Values, Prepared>> & SynchronousResult<Prepared>,\n): FeatureInstance<Id, Prepared>;\nfunction openFeature<const Id extends string, const Runtime extends ModuleRuntimeRecord<Id>>(\n  definition: ModuleDefinition<Id, Runtime>,\n  options: unknown,\n): FeatureInstance<Id, unknown> {\n  const snapshot = snapshotModuleGenerationOptions(definition, options);\n  const instance = instantiateModule(definition, {\n    cleanupFailure: snapshot.cleanupFailure,\n    reporter: snapshot.reporter,\n  });\n\n  return createModuleGenerationController(\n    definition.id,\n    instance,\n    snapshot.prepare,\n    snapshot.reporter,\n    snapshot.scopes,\n  );\n}\n\nexport {\n  carryFeatureGenerationFence,\n  fenceFeatureGeneration,\n  notReadyGeneration,\n  openFeature,\n  quarantinedGeneration,\n  registerFeatureGenerationFence,\n};\nexport type { FeatureInstance };\n"],"names":["emptyScopeValueEntries","moduleGenerationOptionKeys","causeSentence","cause","failedSubject","failure","notReadyGeneration","moduleId","where","FeatureError","generationFences","fenceFeatureGeneration","generation","_a","registerFeatureGenerationFence","fence","carryFeatureGenerationFence","from","to","quarantineRetry","retryOperation","pending","operation","release","retry","quarantinedGeneration","failures","snapshotScopeValues","definition","value","assertPlainRecord","expected","getModuleScopeEntries","expectedKeys","entry","propertyKeys","propertyKey","missing","hasOwn","assertKnownModuleGenerationOptionKeys","assertRequiredModuleGenerationOptions","snapshotGenerationCleanupFailure","cleanupFailure","snapshotGenerationPrepare","prepare","snapshotGenerationReporter","reporter","snapshotModuleGenerationOptions","isThenable","failedScopeCall","failedScopeOutcome","outcome","openGenerationScope","instance","superviseInvalidPreparation","result","error","reportRuntimeFailure","createModuleGenerationController","scopeEntries","inactiveReason","openingCommitted","retirementRequested","retirementAttempt","quarantineError","projectModuleCleanupFailures","handle","attempt","nextOutcome","startRetirement","cancellationReason","releaseScopeEntries","prepared","preparationFailure","asynchronousPreparation","opening","inactive","reason","ready","openFeature","options","snapshot","instantiateModule"],"mappings":"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"}

package/dist/module-instance-types.d.ts

@@ -0,0 +1,156 @@
+import type { Call, DeclarationId } from '@opetope/core';
+import type { AttachmentDrainOutcome, AttachmentIntentOutcome, AttachmentReadinessRef, AttachmentRetryOutcome } from '@opetope/core/internal';
+import type { LifetimeAttachmentRef, ScopeBlueprint } from './attachment-declaration.js';
+import type { AttachmentCallbackInvoker, AttachmentErrorReporter } from './attachment-execution.js';
+import type { MaterializationBinding } from './feature-materialization-binding.js';
+import type { ModuleCallRegistry } from './module-call-runtime.js';
+import type { AttachmentTemplateSlot, CompiledModuleTemplateIR, ScopeAttachmentSlot, ScopeTemplateSlot } from './module-template-ir.js';
+import type { OwnerBoundAttachment, OwnerGeneration, OwnerGenerationController, OwnerGenerationPlanRetirement, OwnerGenerationRef } from './owner-generation.js';
+declare const localAttachmentModuleInstanceBrand: unique symbol;
+declare const localScopeInstanceBrand: unique symbol;
+declare const localScopeRetirementBrand: unique symbol;
+interface LocalScopeClosedOutcome {
+    readonly kind: 'closed';
+}
+interface LocalAttachmentIdentity {
+    readonly attachmentId: DeclarationId;
+    readonly attachmentSlot: AttachmentTemplateSlot;
+}
+/**
+ * One shape for one fact: the physical close of an attachment either quarantined itself or rejected. The scheduler,
+ * the local scope and the retire handle all speak this form, so no layer reprojects it (D164).
+ */
+type LocalAttachmentCloseFailureOutcome = Extract<AttachmentDrainOutcome | AttachmentRetryOutcome, {
+    readonly kind: 'quarantined';
+}> | {
+    readonly error: unknown;
+    readonly kind: 'rejected';
+};
+interface LocalAttachmentCloseFailure extends LocalAttachmentIdentity {
+    readonly outcome: LocalAttachmentCloseFailureOutcome;
+}
+interface LocalScopeQuarantinedOutcome {
+    readonly failedAttachments: readonly LocalAttachmentCloseFailure[];
+    readonly kind: 'quarantined';
+}
+type LocalScopeDrainOutcome = LocalScopeClosedOutcome | LocalScopeQuarantinedOutcome;
+/** One pair of handles for one fact: the scheduler and the scope retire handle answer the same two questions. */
+interface AttachmentRetirementScheduler {
+    readonly drain: () => Promise<LocalScopeDrainOutcome>;
+    readonly retry: () => Promise<LocalScopeDrainOutcome>;
+}
+interface LocalScopeRetirement extends AttachmentRetirementScheduler {
+    readonly [localScopeRetirementBrand]: true;
+}
+interface LocalScopeReadyOutcome {
+    readonly kind: 'ready';
+}
+interface LocalScopeNotReadyOutcome {
+    readonly attachmentId: DeclarationId;
+    readonly attachmentSlot: AttachmentTemplateSlot;
+    readonly drain: LocalScopeDrainOutcome;
+    readonly kind: 'not-ready';
+    readonly outcome: AttachmentIntentOutcome;
+    readonly retirement: LocalScopeRetirement;
+}
+interface LocalScopeRetiredOutcome {
+    readonly drain: LocalScopeDrainOutcome;
+    readonly kind: 'retired';
+    readonly retirement: LocalScopeRetirement;
+}
+type LocalScopeOpenOutcome = LocalScopeNotReadyOutcome | LocalScopeReadyOutcome | LocalScopeRetiredOutcome;
+interface LocalScopeInstance<Value> {
+    readonly [localScopeInstanceBrand]: true;
+    readonly open: (value: Value) => Promise<LocalScopeOpenOutcome>;
+    readonly ref: OwnerGenerationRef;
+    readonly retire: () => LocalScopeRetirement;
+}
+interface LocalAttachmentModuleDiagnostics {
+    readonly activeScopes: number;
+    readonly attachmentControllers: number;
+    readonly deferredFailures: readonly LocalDeferredAttachmentFailure[];
+    readonly scopeControllers: number;
+}
+interface LocalDeferredAttachmentFailure extends LocalAttachmentIdentity {
+    readonly outcome: DeferredAttachmentFailureOutcome;
+}
+interface LocalAttachmentModuleInstance {
+    readonly diagnostics: () => LocalAttachmentModuleDiagnostics;
+    readonly [localAttachmentModuleInstanceBrand]: true;
+    readonly readiness: <Value>(attachment: LifetimeAttachmentRef<Value>) => AttachmentReadinessRef;
+    readonly scope: <Value>(scope: ScopeBlueprint<Value>) => LocalScopeInstance<Value>;
+}
+type AttachmentInstance = {
+    readonly bound: OwnerBoundAttachment<unknown>;
+    readonly id: DeclarationId;
+    readonly scopeAttachmentSlot: ScopeAttachmentSlot;
+    readonly slot: AttachmentTemplateSlot;
+};
+type ScopeGenerationPhase = 'committing' | 'fencing' | 'opening' | 'ready' | 'retiring';
+type CriticalFailure = {
+    readonly attachment: AttachmentInstance;
+    readonly outcome: AttachmentIntentOutcome;
+};
+type DeferredAttachmentFailureOutcome = Extract<AttachmentIntentOutcome, {
+    readonly kind: 'failed' | 'quarantined';
+}> | {
+    readonly error: unknown;
+    readonly kind: 'rejected';
+};
+type ScopeGeneration = {
+    readonly attachmentStates: Uint8Array;
+    callbackInvocationDepth: number;
+    criticalPending: number;
+    failure: CriticalFailure | undefined;
+    readonly generation: OwnerGeneration;
+    readonly invokeAttachmentCallback: AttachmentCallbackInvoker;
+    openingValue: unknown;
+    readonly openPromise: Promise<LocalScopeOpenOutcome>;
+    phase: ScopeGenerationPhase;
+    rejectOpen: (error: unknown) => void;
+    resolveOpen: (outcome: LocalScopeOpenOutcome) => void;
+    retirement: RetirementRecord | undefined;
+    unstartedAttachments: number;
+    value: unknown;
+};
+type ScopeInstanceRecord = {
+    active: ScopeGeneration | undefined;
+    readonly attachmentInstances: readonly AttachmentInstance[];
+    readonly controller: OwnerGenerationController;
+    readonly deferredFailures: Map<AttachmentInstance, DeferredAttachmentFailureOutcome>;
+    readonly runtime: LocalScopeInstance<unknown>;
+    readonly slot: ScopeTemplateSlot;
+};
+/** One record per live instance: everything the runtime knows about it hangs here, not in parallel indexes (D166). */
+type ModuleInstanceRecord = {
+    readonly attachments: readonly AttachmentInstance[];
+    readonly callRegistry: ModuleCallRegistry;
+    readonly callTargets: readonly Call<unknown, unknown>[];
+    readonly deferredFailures: Map<AttachmentInstance, DeferredAttachmentFailureOutcome>;
+    readonly materializationBindings: readonly (MaterializationBinding | undefined)[];
+    readonly plan: CompiledModuleTemplateIR;
+    readonly reporterState: AttachmentErrorReporterState;
+    readonly retainScopeValues: boolean;
+    readonly scopes: readonly ScopeInstanceRecord[];
+};
+type AttachmentErrorReporterState = {
+    reporter: AttachmentErrorReporter | undefined;
+};
+type RetirementRecord = {
+    drainPromise: Promise<LocalScopeDrainOutcome> | undefined;
+    readonly handleState: RetirementHandleState;
+    ownerRetirement: OwnerGenerationPlanRetirement | undefined;
+    prepared: Promise<void> | undefined;
+    rejectPrepared: (error: unknown) => void;
+    resolvePrepared: () => void;
+    retryPromise: Promise<LocalScopeDrainOutcome> | undefined;
+    runtime: LocalScopeRetirement;
+    scheduler: AttachmentRetirementScheduler | undefined;
+    scope: ScopeInstanceRecord | undefined;
+    state: ScopeGeneration | undefined;
+};
+type RetirementHandleState = {
+    outcome: LocalScopeDrainOutcome | undefined;
+    record: RetirementRecord | undefined;
+};
+export type { AttachmentErrorReporterState, AttachmentInstance, AttachmentRetirementScheduler, DeferredAttachmentFailureOutcome, LocalAttachmentCloseFailure, LocalAttachmentCloseFailureOutcome, LocalAttachmentIdentity, LocalAttachmentModuleDiagnostics, LocalAttachmentModuleInstance, LocalDeferredAttachmentFailure, LocalScopeDrainOutcome, LocalScopeInstance, LocalScopeOpenOutcome, LocalScopeRetirement, ModuleInstanceRecord, RetirementHandleState, RetirementRecord, ScopeGeneration, ScopeGenerationPhase, ScopeInstanceRecord, };

package/dist/module-instance.d.ts

@@ -0,0 +1,19 @@
+import type { Call } from '@opetope/core';
+import type { AttachmentCallRef } from './attachment-call-declaration.js';
+import type { ScopeBlueprint } from './attachment-declaration.js';
+import type { AttachmentErrorReporter } from './attachment-execution.js';
+import type { LocalAttachmentModuleInstance, LocalScopeInstance, LocalScopeRetirement, ModuleInstanceRecord } from './module-instance-types.js';
+import type { CompiledModuleTemplateIR } from './module-template-ir.js';
+declare function requireModuleInstanceRecord(instance: LocalAttachmentModuleInstance): ModuleInstanceRecord;
+declare function hasActiveLocalAttachmentCallback(record: ModuleInstanceRecord): boolean;
+declare function revokeLocalAttachmentModuleCallTargets(record: ModuleInstanceRecord): void;
+/** Every live half of an instance hangs on its record, so the layers above pass the record, not a handle (D166). */
+declare function resolveAttachmentCallTarget<Input, Output>(record: ModuleInstanceRecord, call: AttachmentCallRef<Input, Output>): Call<Input, Output>;
+declare function retireLocalScopeIfActive<Value>(record: ModuleInstanceRecord, scope: ScopeBlueprint<Value>): LocalScopeRetirement | undefined;
+declare function localScopeInstance<Value>(record: ModuleInstanceRecord, scope: ScopeBlueprint<Value>): LocalScopeInstance<Value>;
+/** The internal entry hands out the authentic handle; the layers inside the package pass the record itself. */
+declare function instantiateModuleTemplate(plan: CompiledModuleTemplateIR): LocalAttachmentModuleInstance;
+declare function instantiateRetainedModuleTemplate(plan: CompiledModuleTemplateIR, reporter?: AttachmentErrorReporter): ModuleInstanceRecord;
+declare function releaseLocalAttachmentErrorReporter(record: ModuleInstanceRecord): void;
+export { hasActiveLocalAttachmentCallback, instantiateModuleTemplate, instantiateRetainedModuleTemplate, localScopeInstance, releaseLocalAttachmentErrorReporter, requireModuleInstanceRecord, resolveAttachmentCallTarget, retireLocalScopeIfActive, revokeLocalAttachmentModuleCallTargets, };
+export type { LocalAttachmentCloseFailure, LocalAttachmentIdentity, LocalAttachmentModuleDiagnostics, LocalAttachmentModuleInstance, LocalScopeDrainOutcome, LocalScopeInstance, LocalScopeOpenOutcome, LocalScopeRetirement, ModuleInstanceRecord, } from './module-instance-types.js';

package/dist/module-instance.js

@@ -0,0 +1,2 @@
+import{createAttachmentLifecycleController as $,mintAttachmentCallTarget as F,assertCallContextCurrent as b,inheritCallContextLifetime as T,inheritCallExecutionMetadata as y,releaseCallExecutionMetadata as h,retireCallContext as g,settleGuardedResult as L,combineAbortSignals as v,withCallTargetResultFinalizer as z,throwIfSignalAborted as B,revokeCallTarget as x}from"@opetope/core/internal";import{invokeAttachmentClose as G,invokeAttachmentOpen as N}from"./attachment-execution.js";import{getCompiledTemplateRecord as D,compiledAttachmentRecipe as W,getCompiledAttachmentSlot as q,getCompiledCallTargetBindingSlot as O,compiledAttachmentCallRecipe as H,getCompiledScopeSlot as P}from"./compile-module-template.js";import{createMaterializationBinding as J,withMaterializationBinding as K}from"./feature-materialization-binding.js";import{bindLocalCallResolver as I}from"./module-call-context.js";import{retireModuleAttachmentCalls as E,createModuleCallRegistry as Q,createModuleCallInvoker as U}from"./module-call-runtime.js";import{deferredFailureDiagnostics as V,beginScopeOpen as X}from"./module-scope-open.js";import{beginScopeRetirement as R}from"./module-scope-retirement.js";import{createOwnerGenerationSlot as Y,bindAttachmentLifecycleToOwner as Z,getOwnerGenerationAuthoritySource as _}from"./owner-generation.js";const tt=new WeakMap;function A(t){return typeof t=="object"&&t!==null||typeof t=="function"}function et(t){return t.scopes.some(n=>{var o;return(((o=n.active)==null?void 0:o.callbackInvocationDepth)??0)!==0})}function nt(t){for(const n of t.callTargets)x(n)}function rt(t,n){const o=O(t.plan,n),i=t.callTargets[o];if(i===void 0)throw new TypeError(`Call-target binding slot ${o} is not instantiated.`);return i}function j(t,n){const o=P(t.plan,n),i=t.scopes[o];if(i===void 0)throw new TypeError(`Scope slot ${o} is not instantiated.`);return i}function ot(t,n){const o=j(t,n);return o.active===void 0?void 0:R(o).runtime}function at(t,n,o){return(i,d)=>{const u=o(n),c=v([d.signal,u.generation.signal]),e=Object.freeze({signal:c.signal,source:u.value,throwIfAborted:()=>B(c.signal)});let r;try{y(d,e),r=t.run(i,e)}catch(s){throw h(e),c.dispose(),s}if(!A(r))try{return e.throwIfAborted(),r}finally{h(e),c.dispose()}return z(r,{assertCurrent:e.throwIfAborted,finalize:()=>{h(e),c.dispose()},signal:c.signal})}}function it(t,n,o,i){return(d,u)=>{const c=o(n),e=v([u.signal,c.generation.signal]),r=Object.freeze({signal:e.signal,source:c.value,throwIfAborted(){b(r)}});I(r,i);const s=r.throwIfAborted;let f;try{T(u,r),y(u,r),f=t.run(d,r)}catch(l){throw h(r),g(r),e.dispose(),l}if(!A(f))try{return s(),f}finally{h(r),g(r),e.dispose()}return z(f,{assertCurrent:s,finalize:()=>{h(r),g(r),e.dispose()},signal:e.signal})}}function ct(t,n,o,i,d,u,c){const e=o.policy;if(e===void 0)throw new TypeError(`Call ${t} lost its compiled policy recipe.`);const r=U(t,n,e,c);return(s,f)=>{const l=d(i);return r({execute:p=>{const a=Object.freeze({signal:p.signal,source:l.value,throwIfAborted(){b(a)}});I(a,u);const w=a.throwIfAborted;let m;try{T(f,a),y(a,a),m=o.run(s,a)}catch(C){throw h(a),g(a),C}if(!A(m))try{return w(),m}finally{h(a),g(a)}return L(m,{assertCurrent:w,finalize:()=>{h(a),g(a)},waitForPhysicalSettlement:!0})},generation:l.generation,input:s,parent:f})}}function st(t,n,o,i,d,u,c){return Object.freeze(t.attachments.map(e=>{const r=o[e.slot];if(r===void 0)throw new TypeError(`Attachment ${e.identity.id} lost its compiled recipe.`);const s=J(r);c[e.slot]=s;const f=$({close:async p=>{const a=i(e.ownerScopeSlot);return await E(u,a.generation,e.slot),G(r,p.signal,a.value,a.invokeAttachmentCallback,d.reporter)},id:e.identity.id,open:p=>{const a=i(e.ownerScopeSlot);return K(s,()=>N(r,p,a.invokeAttachmentCallback,d.reporter,()=>E(u,a.generation,e.slot)))}}),l=n[e.ownerScopeSlot];if(l===void 0)throw new TypeError(`Attachment ${e.identity.id} lost its compiled owner scope.`);return Object.freeze({bound:Z(l.ref,f),id:e.identity.id,scopeAttachmentSlot:e.scopeAttachmentSlot,slot:e.slot})}))}function lt(t,n,o,i,d,u){const c={current:void 0},e=s=>{var p;const f=O(t,s),l=(p=c.current)==null?void 0:p[f];if(l===void 0)throw new TypeError(`Call-target binding slot ${f} is not instantiated.`);return l},r=Object.freeze(t.callTargetBindings.map(s=>{const f=o[s.withinAttachmentSlot];if(f===void 0)throw new TypeError(`Call target ${s.id} lost its attachment binding.`);const l=t.attachments[s.withinAttachmentSlot];if(l===void 0)throw new TypeError(`Call target ${s.id} lost its attachment node.`);const p=i[l.ownerScopeSlot];if(p===void 0)throw new TypeError(`Call target ${s.id} lost its owner binding.`);const a=H(n,s.slot),w=a.nestedFeatureCalls===!0,m=a.policy!==void 0?ct(s.id,s.withinAttachmentSlot,a,l.ownerScopeSlot,d,e,u):w?it(a,l.ownerScopeSlot,d,e):at(a,l.ownerScopeSlot,d);return F({id:s.id,owner:_(p),run:m,within:f.bound.readiness})}));return c.current=r,r}function ut(t,n,o){const{attachments:i,deferredFailures:d,plan:u}=t;u.scopes.forEach(c=>{var f;const e=Object.freeze({open:l=>X(t,n[c.slot],l),ref:(f=o[c.slot])==null?void 0:f.ref,retire:()=>R(n[c.slot]).runtime});if(e.ref===void 0)throw new TypeError(`Scope ${c.identity.id} lost its owner controller.`);const s={active:void 0,attachmentInstances:Object.freeze(c.attachmentSlots.map(l=>{const p=i[l];if(p===void 0)throw new TypeError(`Attachment slot ${l} is not instantiated.`);return p})),controller:o[c.slot],deferredFailures:d,runtime:e,slot:c.slot};n[c.slot]=s})}function M(t,n){return j(t,n).runtime}function ft(t){const{attachments:n,plan:o}=t;return Object.freeze({diagnostics(){return Object.freeze({activeScopes:t.scopes.filter(i=>i.active!==void 0).length,attachmentControllers:n.length,deferredFailures:V(t),scopeControllers:t.scopes.length})},readiness(i){const d=q(o,i),u=n[d];if(u===void 0)throw new TypeError(`Attachment slot ${d} is not instantiated.`);return u.bound.readiness},scope(i){return M(t,i)}})}function k(t,n,o){const i=D(t),d=Object.freeze(t.attachments.map(m=>W(i,m.slot))),u=Object.freeze(t.scopes.map(m=>Y({id:m.identity.id}))),c=new Map,e={reporter:o},r=[],s=m=>{var S;const C=(S=r[m])==null?void 0:S.active;if(C===void 0)throw new TypeError(`Scope slot ${m} has no active generation value.`);return C},f=Q(),l=[],p=st(t,u,d,s,e,f,l),a=lt(t,i,p,u,s,f),w={attachments:p,callRegistry:f,callTargets:a,deferredFailures:c,materializationBindings:Object.freeze(l),plan:t,reporterState:e,retainScopeValues:n,scopes:r};return ut(w,r,u),Object.freeze(r),w}function dt(t){const n=k(t,!1),o=ft(n);return tt.set(o,n),o}function pt(t,n){return k(t,!0,n)}function mt(t){t.reporterState.reporter=void 0}export{et as hasActiveLocalAttachmentCallback,dt as instantiateModuleTemplate,pt as instantiateRetainedModuleTemplate,M as localScopeInstance,mt as releaseLocalAttachmentErrorReporter,rt as resolveAttachmentCallTarget,ot as retireLocalScopeIfActive,nt as revokeLocalAttachmentModuleCallTargets};
+//# sourceMappingURL=module-instance.js.map

package/dist/module-instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-instance.js","sources":["../src/module-instance.ts"],"sourcesContent":["import type { Call } from '@opetope/core';\nimport type { AttachmentReadinessRef, CallContext } from '@opetope/core/internal';\nimport {\n  assertCallContextCurrent,\n  combineAbortSignals,\n  createAttachmentLifecycleController,\n  inheritCallContextLifetime,\n  inheritCallExecutionMetadata,\n  mintAttachmentCallTarget,\n  releaseCallExecutionMetadata,\n  retireCallContext,\n  revokeCallTarget,\n  settleGuardedResult,\n  throwIfSignalAborted,\n  withCallTargetResultFinalizer,\n} from '@opetope/core/internal';\n\nimport type { AttachmentCallRef, CompiledAttachmentCallRecipe } from './attachment-call-declaration';\nimport type { LifetimeAttachmentRef, ScopeBlueprint } from './attachment-declaration';\nimport { invokeAttachmentClose, invokeAttachmentOpen } from './attachment-execution';\nimport type { AttachmentErrorReporter } from './attachment-execution';\nimport {\n  compiledAttachmentCallRecipe,\n  compiledAttachmentRecipe,\n  getCompiledAttachmentSlot,\n  getCompiledCallTargetBindingSlot,\n  getCompiledScopeSlot,\n  getCompiledTemplateRecord,\n} from './compile-module-template';\nimport type { CompiledModuleTemplateRecord } from './compile-module-template';\nimport { createMaterializationBinding, withMaterializationBinding } from './feature-materialization-binding';\nimport type { MaterializationBinding } from './feature-materialization-binding';\nimport { bindLocalCallResolver } from './module-call-context';\nimport { createModuleCallInvoker, createModuleCallRegistry, retireModuleAttachmentCalls } from './module-call-runtime';\nimport type { ModuleCallRegistry } from './module-call-runtime';\nimport type {\n  AttachmentErrorReporterState,\n  AttachmentInstance,\n  DeferredAttachmentFailureOutcome,\n  LocalAttachmentModuleDiagnostics,\n  LocalAttachmentModuleInstance,\n  LocalScopeInstance,\n  LocalScopeOpenOutcome,\n  LocalScopeRetirement,\n  ModuleInstanceRecord,\n  ScopeGeneration,\n  ScopeInstanceRecord,\n} from './module-instance-types';\nimport { beginScopeOpen, deferredFailureDiagnostics } from './module-scope-open';\nimport { beginScopeRetirement } from './module-scope-retirement';\nimport type { CompiledModuleTemplateIR, ScopeTemplateSlot } from './module-template-ir';\nimport {\n  bindAttachmentLifecycleToOwner,\n  createOwnerGenerationSlot,\n  getOwnerGenerationAuthoritySource,\n} from './owner-generation';\nimport type { OwnerGeneration, OwnerGenerationController } from './owner-generation';\nimport type { ModuleCallContext } from './public-module';\n\nconst moduleInstances = new WeakMap<object, ModuleInstanceRecord>();\n\ntype AttachmentCallRun = (input: unknown, context: CallContext) => unknown;\ntype ReadScopeState = (slot: ScopeTemplateSlot) => ScopeGeneration;\ntype ResolveLocalCall = <Input, Output>(call: AttachmentCallRef<Input, Output>) => Call<Input, Output>;\n\nfunction canHaveThen(value: unknown): value is ((...arguments_: never[]) => unknown) | object {\n  return (typeof value === 'object' && value !== null) || typeof value === 'function';\n}\n\nfunction requireModuleInstanceRecord(instance: LocalAttachmentModuleInstance): ModuleInstanceRecord {\n  const record = moduleInstances.get(instance);\n\n  if (record === undefined) throw new TypeError('Inauthentic local instance.');\n\n  return record;\n}\n\nfunction hasActiveLocalAttachmentCallback(record: ModuleInstanceRecord): boolean {\n  return record.scopes.some(scope => (scope.active?.callbackInvocationDepth ?? 0) !== 0);\n}\n\nfunction revokeLocalAttachmentModuleCallTargets(record: ModuleInstanceRecord): void {\n  for (const target of record.callTargets) revokeCallTarget(target);\n}\n\n/** Every live half of an instance hangs on its record, so the layers above pass the record, not a handle (D166). */\nfunction resolveAttachmentCallTarget<Input, Output>(\n  record: ModuleInstanceRecord,\n  call: AttachmentCallRef<Input, Output>,\n): Call<Input, Output> {\n  const slot = getCompiledCallTargetBindingSlot(record.plan, call);\n  const target = record.callTargets[slot];\n\n  if (target === undefined) throw new TypeError(`Call-target binding slot ${slot} is not instantiated.`);\n\n  return target as Call<Input, Output>;\n}\n\nfunction requireLocalScopeRecord<Value>(record: ModuleInstanceRecord, scope: ScopeBlueprint<Value>) {\n  const slot = getCompiledScopeSlot(record.plan, scope);\n  const scopeRecord = record.scopes[slot];\n\n  if (scopeRecord === undefined) throw new TypeError(`Scope slot ${slot} is not instantiated.`);\n\n  return scopeRecord;\n}\n\nfunction retireLocalScopeIfActive<Value>(\n  record: ModuleInstanceRecord,\n  scope: ScopeBlueprint<Value>,\n): LocalScopeRetirement | undefined {\n  const scopeRecord = requireLocalScopeRecord(record, scope);\n\n  return scopeRecord.active === undefined ? undefined : beginScopeRetirement(scopeRecord).runtime;\n}\n\nfunction createAttachmentCallRun(\n  recipe: CompiledAttachmentCallRecipe<unknown, unknown>,\n  scopeSlot: ScopeTemplateSlot,\n  readScopeState: ReadScopeState,\n): AttachmentCallRun {\n  return (input, context) => {\n    const state = readScopeState(scopeSlot);\n    const combined = combineAbortSignals([context.signal, state.generation.signal]);\n    const callContext: ModuleCallContext<unknown> = Object.freeze({\n      signal: combined.signal,\n      source: state.value,\n      throwIfAborted: () => throwIfSignalAborted(combined.signal),\n    });\n    let result: unknown;\n\n    try {\n      inheritCallExecutionMetadata(context, callContext);\n      result = recipe.run(input, callContext);\n    } catch (error) {\n      releaseCallExecutionMetadata(callContext);\n      combined.dispose();\n      throw error;\n    }\n\n    if (!canHaveThen(result)) {\n      try {\n        callContext.throwIfAborted();\n\n        return result;\n      } finally {\n        releaseCallExecutionMetadata(callContext);\n        combined.dispose();\n      }\n    }\n\n    return withCallTargetResultFinalizer(result, {\n      assertCurrent: callContext.throwIfAborted,\n      finalize: () => {\n        releaseCallExecutionMetadata(callContext);\n        combined.dispose();\n      },\n      signal: combined.signal,\n    });\n  };\n}\n\nfunction createNestedFeatureCallRun(\n  recipe: CompiledAttachmentCallRecipe<unknown, unknown>,\n  scopeSlot: ScopeTemplateSlot,\n  readScopeState: ReadScopeState,\n  resolveLocalCall: ResolveLocalCall,\n): AttachmentCallRun {\n  return (input, context) => {\n    const state = readScopeState(scopeSlot);\n    const combined = combineAbortSignals([context.signal, state.generation.signal]);\n    const callContext: ModuleCallContext<unknown> = Object.freeze({\n      signal: combined.signal,\n      source: state.value,\n      throwIfAborted(): void {\n        assertCallContextCurrent(callContext);\n      },\n    });\n    bindLocalCallResolver(callContext, resolveLocalCall);\n    const assertCurrent = callContext.throwIfAborted;\n    let result: unknown;\n\n    try {\n      inheritCallContextLifetime(context, callContext);\n      inheritCallExecutionMetadata(context, callContext);\n      result = recipe.run(input, callContext);\n    } catch (error) {\n      releaseCallExecutionMetadata(callContext);\n      retireCallContext(callContext);\n      combined.dispose();\n      throw error;\n    }\n\n    if (!canHaveThen(result)) {\n      try {\n        assertCurrent();\n\n        return result;\n      } finally {\n        releaseCallExecutionMetadata(callContext);\n        retireCallContext(callContext);\n        combined.dispose();\n      }\n    }\n\n    return withCallTargetResultFinalizer(result, {\n      assertCurrent,\n      finalize: () => {\n        releaseCallExecutionMetadata(callContext);\n        retireCallContext(callContext);\n        combined.dispose();\n      },\n      signal: combined.signal,\n    });\n  };\n}\n\nfunction createFeatureCallRun(\n  id: string,\n  attachmentSlot: number,\n  recipe: CompiledAttachmentCallRecipe<unknown, unknown>,\n  scopeSlot: ScopeTemplateSlot,\n  readScopeState: ReadScopeState,\n  resolveLocalCall: ResolveLocalCall,\n  callRegistry: ModuleCallRegistry,\n): AttachmentCallRun {\n  const policy = recipe.policy;\n\n  if (policy === undefined) throw new TypeError(`Call ${id} lost its compiled policy recipe.`);\n\n  const invokeModuleCall = createModuleCallInvoker(id, attachmentSlot, policy, callRegistry);\n\n  return (input, context) => {\n    const state = readScopeState(scopeSlot);\n\n    return invokeModuleCall({\n      execute: executionContext => {\n        const callContext: ModuleCallContext<unknown> = Object.freeze({\n          signal: executionContext.signal,\n          source: state.value,\n          throwIfAborted(): void {\n            assertCallContextCurrent(callContext);\n          },\n        });\n        bindLocalCallResolver(callContext, resolveLocalCall);\n        const assertCurrent = callContext.throwIfAborted;\n        let result: unknown;\n\n        try {\n          inheritCallContextLifetime(context, callContext);\n          inheritCallExecutionMetadata(callContext, callContext);\n          result = recipe.run(input, callContext);\n        } catch (error) {\n          releaseCallExecutionMetadata(callContext);\n          retireCallContext(callContext);\n          throw error;\n        }\n\n        if (!canHaveThen(result)) {\n          try {\n            assertCurrent();\n\n            return result;\n          } finally {\n            releaseCallExecutionMetadata(callContext);\n            retireCallContext(callContext);\n          }\n        }\n\n        return settleGuardedResult(result, {\n          assertCurrent,\n          finalize: () => {\n            releaseCallExecutionMetadata(callContext);\n            retireCallContext(callContext);\n          },\n          // The executor owns prompt cancellation. Its body result must still join physical completion.\n          waitForPhysicalSettlement: true,\n        });\n      },\n      generation: state.generation,\n      input,\n      parent: context,\n    });\n  };\n}\n\nfunction createAttachmentInstances(\n  plan: CompiledModuleTemplateIR,\n  controllers: readonly OwnerGenerationController[],\n  recipes: readonly ReturnType<typeof compiledAttachmentRecipe>[],\n  readScopeState: ReadScopeState,\n  reporterState: AttachmentErrorReporterState,\n  callRegistry: ModuleCallRegistry,\n  materializationBindings: (MaterializationBinding | undefined)[],\n): readonly AttachmentInstance[] {\n  return Object.freeze(\n    plan.attachments.map(node => {\n      const recipe = recipes[node.slot];\n\n      if (recipe === undefined) throw new TypeError(`Attachment ${node.identity.id} lost its compiled recipe.`);\n\n      const materializationBinding = createMaterializationBinding(recipe);\n      materializationBindings[node.slot] = materializationBinding;\n\n      const lifecycle = createAttachmentLifecycleController<OwnerGeneration, unknown>({\n        close: async context => {\n          const state = readScopeState(node.ownerScopeSlot);\n\n          await retireModuleAttachmentCalls(callRegistry, state.generation, node.slot);\n\n          return invokeAttachmentClose(\n            recipe,\n            context.signal,\n            state.value,\n            state.invokeAttachmentCallback,\n            reporterState.reporter,\n          );\n        },\n        id: node.identity.id,\n        open: context => {\n          const state = readScopeState(node.ownerScopeSlot);\n\n          return withMaterializationBinding(materializationBinding, () =>\n            invokeAttachmentOpen(recipe, context, state.invokeAttachmentCallback, reporterState.reporter, () =>\n              retireModuleAttachmentCalls(callRegistry, state.generation, node.slot),\n            ),\n          );\n        },\n      });\n      const owner = controllers[node.ownerScopeSlot];\n\n      if (owner === undefined) throw new TypeError(`Attachment ${node.identity.id} lost its compiled owner scope.`);\n\n      return Object.freeze({\n        bound: bindAttachmentLifecycleToOwner(owner.ref, lifecycle),\n        id: node.identity.id,\n        scopeAttachmentSlot: node.scopeAttachmentSlot,\n        slot: node.slot,\n      });\n    }),\n  );\n}\n\nfunction createCallTargets(\n  plan: CompiledModuleTemplateIR,\n  template: CompiledModuleTemplateRecord,\n  attachments: readonly AttachmentInstance[],\n  controllers: readonly OwnerGenerationController[],\n  readScopeState: (slot: ScopeTemplateSlot) => ScopeGeneration,\n  callRegistry: ModuleCallRegistry,\n): readonly Call<unknown, unknown>[] {\n  const targetState: { current: readonly Call<unknown, unknown>[] | undefined } = { current: undefined };\n  const resolveLocalCall: ResolveLocalCall = <Input, Output>(call: AttachmentCallRef<Input, Output>) => {\n    const slot = getCompiledCallTargetBindingSlot(plan, call);\n    const target = targetState.current?.[slot];\n\n    if (target === undefined) throw new TypeError(`Call-target binding slot ${slot} is not instantiated.`);\n\n    return target as Call<Input, Output>;\n  };\n  const targets = Object.freeze(\n    plan.callTargetBindings.map(binding => {\n      const attachment = attachments[binding.withinAttachmentSlot];\n\n      if (attachment === undefined) {\n        throw new TypeError(`Call target ${binding.id} lost its attachment binding.`);\n      }\n\n      const attachmentNode = plan.attachments[binding.withinAttachmentSlot];\n\n      if (attachmentNode === undefined) throw new TypeError(`Call target ${binding.id} lost its attachment node.`);\n\n      const owner = controllers[attachmentNode.ownerScopeSlot];\n\n      if (owner === undefined) throw new TypeError(`Call target ${binding.id} lost its owner binding.`);\n\n      const recipe = compiledAttachmentCallRecipe(template, binding.slot);\n      const usesNestedFeatureCalls = recipe.nestedFeatureCalls === true;\n      const run =\n        recipe.policy !== undefined\n          ? createFeatureCallRun(\n              binding.id,\n              binding.withinAttachmentSlot,\n              recipe,\n              attachmentNode.ownerScopeSlot,\n              readScopeState,\n              resolveLocalCall,\n              callRegistry,\n            )\n          : usesNestedFeatureCalls\n            ? createNestedFeatureCallRun(recipe, attachmentNode.ownerScopeSlot, readScopeState, resolveLocalCall)\n            : createAttachmentCallRun(recipe, attachmentNode.ownerScopeSlot, readScopeState);\n\n      return mintAttachmentCallTarget({\n        id: binding.id,\n        owner: getOwnerGenerationAuthoritySource(owner),\n        run,\n        within: attachment.bound.readiness,\n      });\n    }),\n  );\n  targetState.current = targets;\n\n  return targets;\n}\n\nfunction createScopeRecords(\n  instance: ModuleInstanceRecord,\n  scopes: ScopeInstanceRecord[],\n  controllers: readonly OwnerGenerationController[],\n): void {\n  const { attachments, deferredFailures, plan } = instance;\n\n  plan.scopes.forEach(node => {\n    const runtime = Object.freeze({\n      open: (value: unknown): Promise<LocalScopeOpenOutcome> => beginScopeOpen(instance, scopes[node.slot]!, value),\n      ref: controllers[node.slot]?.ref,\n      retire: (): LocalScopeRetirement => beginScopeRetirement(scopes[node.slot]!).runtime,\n    }) as LocalScopeInstance<unknown>;\n\n    if (runtime.ref === undefined) throw new TypeError(`Scope ${node.identity.id} lost its owner controller.`);\n\n    const attachmentInstances = Object.freeze(\n      node.attachmentSlots.map(slot => {\n        const attachment = attachments[slot];\n\n        if (attachment === undefined) throw new TypeError(`Attachment slot ${slot} is not instantiated.`);\n\n        return attachment;\n      }),\n    );\n    const scopeRecord: ScopeInstanceRecord = {\n      active: undefined,\n      attachmentInstances,\n      controller: controllers[node.slot]!,\n      deferredFailures,\n      runtime,\n      slot: node.slot,\n    };\n    scopes[node.slot] = scopeRecord;\n  });\n}\n\nfunction localScopeInstance<Value>(\n  record: ModuleInstanceRecord,\n  scope: ScopeBlueprint<Value>,\n): LocalScopeInstance<Value> {\n  return requireLocalScopeRecord(record, scope).runtime;\n}\n\nfunction createModuleInstanceRuntime(instanceRecord: ModuleInstanceRecord): LocalAttachmentModuleInstance {\n  const { attachments, plan } = instanceRecord;\n\n  return Object.freeze({\n    diagnostics(): LocalAttachmentModuleDiagnostics {\n      return Object.freeze({\n        activeScopes: instanceRecord.scopes.filter(scope => scope.active !== undefined).length,\n        attachmentControllers: attachments.length,\n        deferredFailures: deferredFailureDiagnostics(instanceRecord),\n        scopeControllers: instanceRecord.scopes.length,\n      });\n    },\n    readiness<Value>(attachment: LifetimeAttachmentRef<Value>): AttachmentReadinessRef {\n      const slot = getCompiledAttachmentSlot(plan, attachment);\n      const attachmentInstance = attachments[slot];\n\n      if (attachmentInstance === undefined) throw new TypeError(`Attachment slot ${slot} is not instantiated.`);\n\n      return attachmentInstance.bound.readiness;\n    },\n    scope<Value>(scope: ScopeBlueprint<Value>): LocalScopeInstance<Value> {\n      return localScopeInstance(instanceRecord, scope);\n    },\n  }) as LocalAttachmentModuleInstance;\n}\n\nfunction instantiateModuleTemplateWithOptions(\n  plan: CompiledModuleTemplateIR,\n  retainScopeValues: boolean,\n  reporter?: AttachmentErrorReporter,\n): ModuleInstanceRecord {\n  const template = getCompiledTemplateRecord(plan);\n  const recipes = Object.freeze(plan.attachments.map(node => compiledAttachmentRecipe(template, node.slot)));\n  const controllers = Object.freeze(plan.scopes.map(scope => createOwnerGenerationSlot({ id: scope.identity.id })));\n  const deferredFailures = new Map<AttachmentInstance, DeferredAttachmentFailureOutcome>();\n  const reporterState: AttachmentErrorReporterState = { reporter };\n  const scopes: ScopeInstanceRecord[] = [];\n  const readScopeState = (slot: ScopeTemplateSlot): ScopeGeneration => {\n    const state = scopes[slot]?.active;\n\n    if (state === undefined) throw new TypeError(`Scope slot ${slot} has no active generation value.`);\n\n    return state;\n  };\n  const callRegistry = createModuleCallRegistry();\n  const materializationBindings: (MaterializationBinding | undefined)[] = [];\n  const attachments = createAttachmentInstances(\n    plan,\n    controllers,\n    recipes,\n    readScopeState,\n    reporterState,\n    callRegistry,\n    materializationBindings,\n  );\n  const callTargets = createCallTargets(plan, template, attachments, controllers, readScopeState, callRegistry);\n  const instanceRecord: ModuleInstanceRecord = {\n    attachments,\n    callRegistry,\n    callTargets,\n    deferredFailures,\n    materializationBindings: Object.freeze(materializationBindings),\n    plan,\n    reporterState,\n    retainScopeValues,\n    scopes,\n  };\n  createScopeRecords(instanceRecord, scopes, controllers);\n  Object.freeze(scopes);\n\n  return instanceRecord;\n}\n\n/** The internal entry hands out the authentic handle; the layers inside the package pass the record itself. */\nfunction instantiateModuleTemplate(plan: CompiledModuleTemplateIR): LocalAttachmentModuleInstance {\n  const record = instantiateModuleTemplateWithOptions(plan, false);\n  const instance = createModuleInstanceRuntime(record);\n  moduleInstances.set(instance, record);\n\n  return instance;\n}\n\nfunction instantiateRetainedModuleTemplate(\n  plan: CompiledModuleTemplateIR,\n  reporter?: AttachmentErrorReporter,\n): ModuleInstanceRecord {\n  return instantiateModuleTemplateWithOptions(plan, true, reporter);\n}\n\nfunction releaseLocalAttachmentErrorReporter(record: ModuleInstanceRecord): void {\n  record.reporterState.reporter = undefined;\n}\n\nexport {\n  hasActiveLocalAttachmentCallback,\n  instantiateModuleTemplate,\n  instantiateRetainedModuleTemplate,\n  localScopeInstance,\n  releaseLocalAttachmentErrorReporter,\n  requireModuleInstanceRecord,\n  resolveAttachmentCallTarget,\n  retireLocalScopeIfActive,\n  revokeLocalAttachmentModuleCallTargets,\n};\nexport type {\n  LocalAttachmentCloseFailure,\n  LocalAttachmentIdentity,\n  LocalAttachmentModuleDiagnostics,\n  LocalAttachmentModuleInstance,\n  LocalScopeDrainOutcome,\n  LocalScopeInstance,\n  LocalScopeOpenOutcome,\n  LocalScopeRetirement,\n  ModuleInstanceRecord,\n} from './module-instance-types';\n"],"names":["moduleInstances","canHaveThen","value","hasActiveLocalAttachmentCallback","record","scope","_a","revokeLocalAttachmentModuleCallTargets","target","revokeCallTarget","resolveAttachmentCallTarget","call","slot","getCompiledCallTargetBindingSlot","requireLocalScopeRecord","getCompiledScopeSlot","scopeRecord","retireLocalScopeIfActive","beginScopeRetirement","createAttachmentCallRun","recipe","scopeSlot","readScopeState","input","context","state","combined","combineAbortSignals","callContext","throwIfSignalAborted","result","inheritCallExecutionMetadata","error","releaseCallExecutionMetadata","withCallTargetResultFinalizer","createNestedFeatureCallRun","resolveLocalCall","assertCallContextCurrent","bindLocalCallResolver","assertCurrent","inheritCallContextLifetime","retireCallContext","createFeatureCallRun","id","attachmentSlot","callRegistry","policy","invokeModuleCall","createModuleCallInvoker","executionContext","settleGuardedResult","createAttachmentInstances","plan","controllers","recipes","reporterState","materializationBindings","node","materializationBinding","createMaterializationBinding","lifecycle","createAttachmentLifecycleController","retireModuleAttachmentCalls","invokeAttachmentClose","withMaterializationBinding","invokeAttachmentOpen","owner","bindAttachmentLifecycleToOwner","createCallTargets","template","attachments","targetState","targets","binding","attachment","attachmentNode","compiledAttachmentCallRecipe","usesNestedFeatureCalls","run","mintAttachmentCallTarget","getOwnerGenerationAuthoritySource","createScopeRecords","instance","scopes","deferredFailures","runtime","beginScopeOpen","localScopeInstance","createModuleInstanceRuntime","instanceRecord","deferredFailureDiagnostics","getCompiledAttachmentSlot","attachmentInstance","instantiateModuleTemplateWithOptions","retainScopeValues","reporter","getCompiledTemplateRecord","compiledAttachmentRecipe","createOwnerGenerationSlot","createModuleCallRegistry","callTargets","instantiateModuleTemplate","instantiateRetainedModuleTemplate","releaseLocalAttachmentErrorReporter"],"mappings":"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"}

package/dist/module-runtime-identity.d.ts

@@ -0,0 +1,4 @@
+import type { DeclarationId } from '@opetope/core';
+import type { RuntimeNodeIdentityIR } from './module-template-ir.js';
+declare const runtimeIdentity: (moduleId: DeclarationId, kind: RuntimeNodeIdentityIR["kind"], key: string) => RuntimeNodeIdentityIR;
+export { runtimeIdentity };

package/dist/module-runtime-identity.js

@@ -0,0 +1,2 @@
+import{declarationId as i}from"@opetope/core";const n=(t,e,r)=>Object.freeze({id:i(`${t}/runtime/${e}/${r}`),key:r,kind:e,moduleId:t,stage:"runtime"});export{n as runtimeIdentity};
+//# sourceMappingURL=module-runtime-identity.js.map

package/dist/module-runtime-identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-runtime-identity.js","sources":["../src/module-runtime-identity.ts"],"sourcesContent":["import { declarationId } from '@opetope/core';\nimport type { DeclarationId } from '@opetope/core';\n\nimport type { RuntimeNodeIdentityIR } from './module-template-ir';\n\nconst runtimeIdentity = (\n  moduleId: DeclarationId,\n  kind: RuntimeNodeIdentityIR['kind'],\n  key: string,\n): RuntimeNodeIdentityIR =>\n  Object.freeze({ id: declarationId(`${moduleId}/runtime/${kind}/${key}`), key, kind, moduleId, stage: 'runtime' });\n\nexport { runtimeIdentity };\n"],"names":["runtimeIdentity","moduleId","kind","key","declarationId"],"mappings":"8CAKA,MAAMA,EAAkB,CACtBC,EACAC,EACAC,IAEA,OAAO,OAAO,CAAE,GAAIC,EAAc,GAAGH,CAAQ,YAAYC,CAAI,IAAIC,CAAG,EAAE,EAAG,IAAAA,EAAK,KAAAD,EAAM,SAAAD,EAAU,MAAO,SAAS,CAAE"}

package/dist/module-scope-open.d.ts

@@ -0,0 +1,4 @@
+import type { LocalDeferredAttachmentFailure, LocalScopeOpenOutcome, ModuleInstanceRecord, ScopeInstanceRecord } from './module-instance-types.js';
+declare function deferredFailureDiagnostics(instance: ModuleInstanceRecord): readonly LocalDeferredAttachmentFailure[];
+declare function beginScopeOpen(instance: ModuleInstanceRecord, scope: ScopeInstanceRecord, value: unknown): Promise<LocalScopeOpenOutcome>;
+export { beginScopeOpen, deferredFailureDiagnostics };

package/dist/module-scope-open.js

@@ -0,0 +1,2 @@
+import{reportDetachedError as u}from"@opetope/core/internal";import{beginScopeRetirement as h}from"./module-scope-retirement.js";import{openOwnerBoundAttachment as j}from"./owner-generation.js";const F=Object.freeze({kind:"ready"}),E=0,k=1,I=2,m=3;function g(n){return n.kind==="committed"&&n.state==="ready"}function D(n){return n.kind==="failed"||n.kind==="quarantined"}function P(n){return Object.freeze({error:n,kind:"rejected"})}function N(n,t,e){if(g(e)){n.deferredFailures.delete(t);return}D(e)&&n.deferredFailures.set(t,e)}function V(n){return Object.freeze([...n.deferredFailures.entries()].sort(([t],[e])=>t.slot-e.slot).map(([t,e])=>Object.freeze({attachmentId:t.id,attachmentSlot:t.slot,outcome:e})))}function p(n,t){const e=n.plan.scopes[t.slot];if(e===void 0)throw new TypeError(`Scope slot ${t.slot} lost its compiled node.`);return e}function S(n,t,e){const r=p(n,t),c=r.attachmentSlots[e];if(c===void 0)throw new TypeError(`Scope attachment slot ${e} is outside scope ${r.identity.id}.`);const i=n.plan.attachments[c];if(i===void 0||i.scopeAttachmentSlot!==e)throw new TypeError(`Scope attachment slot ${e} lost its compiled attachment node.`);return i}function z(n,t){const e=n.attachmentInstances[t];if(e===void 0||e.scopeAttachmentSlot!==t)throw new TypeError(`Scope attachment slot ${t} is not instantiated.`);return e}function s(n,t){return n==="critical"?t==="opening":t==="ready"}function y(n,t,e){if(t.rejectOpen(e),t.phase!=="opening"){u(e);return}try{h(n)}catch(r){u(r)}}function O(n,t,e){n.deferredFailures.set(t,P(e)),u(e)}function A(n){n.phase==="ready"&&n.unstartedAttachments===0&&(n.openingValue=void 0)}function T(n,t,e,r,c,i){e.attachmentStates[c]=I,i==="critical"?e.criticalPending-=1:n.deferredFailures.delete(r),i==="critical"&&e.criticalPending===0&&w(n,t,e)}function $(n,t,e,r,c,i,o){if(!(t.active!==e||!s(i,e.phase))){if(g(o)){T(n,t,e,r,c,i);return}if(e.attachmentStates[c]=m,i==="deferred"){N(n,r,o);return}if(e.failure===void 0){e.failure=Object.freeze({attachment:r,outcome:o});try{h(t)}catch(d){u(d)}}}}function q(n,t,e,r){const c=S(n,t,r);if(t.active!==e||e.attachmentStates[r]!==E||!s(c.readiness,e.phase))return;const i=z(t,r),o=e.openingValue;e.attachmentStates[r]=k,e.unstartedAttachments-=1;let d;try{d=j(i.bound,e.generation,o)}catch(a){e.attachmentStates[r]=m,c.readiness==="critical"?y(t,e,a):O(n,i,a);return}A(e),d.then(a=>$(n,t,e,i,r,c.readiness,a),a=>{if(t.active!==e||!s(c.readiness,e.phase)){u(a);return}e.attachmentStates[r]=m,c.readiness==="critical"?y(t,e,a):O(n,i,a)})}function b(n,t,e,r){p(n,t).attachmentSlots.forEach((i,o)=>{const d=o;S(n,t,d).readiness===r&&q(n,t,e,d)})}function w(n,t,e){t.active!==e||e.phase!=="opening"||(e.phase="committing",t.controller.commit(e.generation),e.retirement===void 0&&(e.phase="ready",b(n,t,e,"deferred"),A(e),e.resolveOpen(F)))}function R(n,t){if((n.phase==="committing"||n.phase==="opening")&&Object.is(n.openingValue,t))return n.openPromise;throw new TypeError("Local scope is already active or retiring.")}function C(n,t,e){b(n,t,e,"critical"),e.criticalPending===0&&w(n,t,e)}function _(n,t,e){t.rejectOpen(e),t.retirement===void 0&&h(n)}function U(n,t,e){const r=t.active;if(r!==void 0)return R(r,e);const c=p(n,t);t.attachmentInstances.forEach(l=>n.deferredFailures.delete(l));const i=t.controller.begin();let o=l=>{},d=l=>{};const a=new Promise((l,v)=>{o=v,d=l}),f={attachmentStates:new Uint8Array(t.attachmentInstances.length),callbackInvocationDepth:0,criticalPending:c.criticalAttachmentSlots.length,failure:void 0,generation:i,invokeAttachmentCallback:l=>{f.callbackInvocationDepth+=1;try{return l()}finally{f.callbackInvocationDepth-=1}},openingValue:e,openPromise:a,phase:"opening",rejectOpen:o,resolveOpen:d,retirement:void 0,unstartedAttachments:t.attachmentInstances.length,value:n.retainScopeValues?e:void 0};t.active=f;try{C(n,t,f)}catch(l){_(t,f,l)}return a}export{U as beginScopeOpen,V as deferredFailureDiagnostics};
+//# sourceMappingURL=module-scope-open.js.map

package/dist/module-scope-open.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-scope-open.js","sources":["../src/module-scope-open.ts"],"sourcesContent":["import { reportDetachedError } from '@opetope/core/internal';\nimport type { AttachmentIntentOutcome } from '@opetope/core/internal';\n\nimport type {\n  AttachmentInstance,\n  DeferredAttachmentFailureOutcome,\n  LocalDeferredAttachmentFailure,\n  LocalScopeOpenOutcome,\n  ModuleInstanceRecord,\n  ScopeGeneration,\n  ScopeGenerationPhase,\n  ScopeInstanceRecord,\n} from './module-instance-types';\nimport { beginScopeRetirement } from './module-scope-retirement';\nimport type { ScopeAttachmentSlot } from './module-template-ir';\nimport { openOwnerBoundAttachment } from './owner-generation';\n\nconst readyOpenOutcome = Object.freeze({ kind: 'ready' as const });\nconst attachmentPending = 0;\nconst attachmentOpening = 1;\nconst attachmentReady = 2;\nconst attachmentFailed = 3;\n\nfunction isReadyOutcome(outcome: AttachmentIntentOutcome): boolean {\n  return outcome.kind === 'committed' && outcome.state === 'ready';\n}\n\nfunction isDeferredFailureOutcome(\n  outcome: AttachmentIntentOutcome,\n): outcome is Extract<AttachmentIntentOutcome, { readonly kind: 'failed' | 'quarantined' }> {\n  return outcome.kind === 'failed' || outcome.kind === 'quarantined';\n}\n\nfunction rejectedDeferredFailure(error: unknown): DeferredAttachmentFailureOutcome {\n  return Object.freeze({ error, kind: 'rejected' as const });\n}\n\nfunction settleDeferredAttachment(\n  instance: ModuleInstanceRecord,\n  attachment: AttachmentInstance,\n  outcome: AttachmentIntentOutcome,\n): void {\n  if (isReadyOutcome(outcome)) {\n    instance.deferredFailures.delete(attachment);\n\n    return;\n  }\n\n  if (isDeferredFailureOutcome(outcome)) instance.deferredFailures.set(attachment, outcome);\n}\n\nfunction deferredFailureDiagnostics(instance: ModuleInstanceRecord): readonly LocalDeferredAttachmentFailure[] {\n  return Object.freeze(\n    [...instance.deferredFailures.entries()]\n      .sort(([left], [right]) => left.slot - right.slot)\n      .map(([attachment, outcome]) =>\n        Object.freeze({ attachmentId: attachment.id, attachmentSlot: attachment.slot, outcome }),\n      ),\n  );\n}\n\nfunction requireScopeNode(instance: ModuleInstanceRecord, scope: ScopeInstanceRecord) {\n  const node = instance.plan.scopes[scope.slot];\n\n  if (node === undefined) throw new TypeError(`Scope slot ${scope.slot} lost its compiled node.`);\n\n  return node;\n}\n\nfunction requireScopeAttachmentNode(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  slot: ScopeAttachmentSlot,\n) {\n  const scopeNode = requireScopeNode(instance, scope);\n  const attachmentSlot = scopeNode.attachmentSlots[slot];\n\n  if (attachmentSlot === undefined) {\n    throw new TypeError(`Scope attachment slot ${slot} is outside scope ${scopeNode.identity.id}.`);\n  }\n\n  const node = instance.plan.attachments[attachmentSlot];\n\n  if (node === undefined || node.scopeAttachmentSlot !== slot) {\n    throw new TypeError(`Scope attachment slot ${slot} lost its compiled attachment node.`);\n  }\n\n  return node;\n}\n\nfunction requireScopeAttachmentInstance(scope: ScopeInstanceRecord, slot: ScopeAttachmentSlot): AttachmentInstance {\n  const attachment = scope.attachmentInstances[slot];\n\n  if (attachment === undefined || attachment.scopeAttachmentSlot !== slot) {\n    throw new TypeError(`Scope attachment slot ${slot} is not instantiated.`);\n  }\n\n  return attachment;\n}\n\nfunction attachmentPhaseAllowsStart(readiness: 'critical' | 'deferred', phase: ScopeGenerationPhase): boolean {\n  return readiness === 'critical' ? phase === 'opening' : phase === 'ready';\n}\n\nfunction failCriticalAttachmentStart(scope: ScopeInstanceRecord, state: ScopeGeneration, error: unknown): void {\n  state.rejectOpen(error);\n\n  if (state.phase !== 'opening') {\n    reportDetachedError(error);\n\n    return;\n  }\n\n  try {\n    beginScopeRetirement(scope);\n  } catch (retirementError) {\n    reportDetachedError(retirementError);\n  }\n}\n\nfunction failDeferredAttachmentStart(\n  instance: ModuleInstanceRecord,\n  attachment: AttachmentInstance,\n  error: unknown,\n): void {\n  instance.deferredFailures.set(attachment, rejectedDeferredFailure(error));\n  reportDetachedError(error);\n}\n\nfunction releaseOpeningValueIfFullyScheduled(state: ScopeGeneration): void {\n  if (state.phase === 'ready' && state.unstartedAttachments === 0) state.openingValue = undefined;\n}\n\nfunction settleReadyAttachment(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  state: ScopeGeneration,\n  attachment: AttachmentInstance,\n  slot: ScopeAttachmentSlot,\n  readiness: 'critical' | 'deferred',\n): void {\n  state.attachmentStates[slot] = attachmentReady;\n\n  if (readiness === 'critical') state.criticalPending -= 1;\n  else instance.deferredFailures.delete(attachment);\n\n  // oxlint-disable-next-line eslint/no-use-before-define -- readiness settlement closes the startup worklist\n  if (readiness === 'critical' && state.criticalPending === 0) commitScopeGeneration(instance, scope, state);\n}\n\nfunction settleAttachmentOpen(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  state: ScopeGeneration,\n  attachment: AttachmentInstance,\n  slot: ScopeAttachmentSlot,\n  readiness: 'critical' | 'deferred',\n  outcome: AttachmentIntentOutcome,\n): void {\n  if (scope.active !== state || !attachmentPhaseAllowsStart(readiness, state.phase)) return;\n\n  if (isReadyOutcome(outcome)) {\n    settleReadyAttachment(instance, scope, state, attachment, slot, readiness);\n\n    return;\n  }\n\n  state.attachmentStates[slot] = attachmentFailed;\n\n  if (readiness === 'deferred') {\n    settleDeferredAttachment(instance, attachment, outcome);\n\n    return;\n  }\n\n  if (state.failure !== undefined) return;\n\n  state.failure = Object.freeze({ attachment, outcome });\n\n  try {\n    beginScopeRetirement(scope);\n  } catch (error) {\n    reportDetachedError(error);\n  }\n}\n\nfunction startEligibleAttachment(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  state: ScopeGeneration,\n  slot: ScopeAttachmentSlot,\n): void {\n  const node = requireScopeAttachmentNode(instance, scope, slot);\n\n  if (\n    scope.active !== state ||\n    state.attachmentStates[slot] !== attachmentPending ||\n    !attachmentPhaseAllowsStart(node.readiness, state.phase)\n  ) {\n    return;\n  }\n\n  const attachment = requireScopeAttachmentInstance(scope, slot);\n  const value = state.openingValue;\n  state.attachmentStates[slot] = attachmentOpening;\n  state.unstartedAttachments -= 1;\n\n  let opening: Promise<AttachmentIntentOutcome>;\n\n  try {\n    opening = openOwnerBoundAttachment(attachment.bound, state.generation, value);\n  } catch (error) {\n    state.attachmentStates[slot] = attachmentFailed;\n\n    if (node.readiness === 'critical') failCriticalAttachmentStart(scope, state, error);\n    else failDeferredAttachmentStart(instance, attachment, error);\n\n    return;\n  }\n\n  releaseOpeningValueIfFullyScheduled(state);\n\n  void opening.then(\n    outcome => settleAttachmentOpen(instance, scope, state, attachment, slot, node.readiness, outcome),\n    (error: unknown) => {\n      if (scope.active !== state || !attachmentPhaseAllowsStart(node.readiness, state.phase)) {\n        reportDetachedError(error);\n\n        return;\n      }\n\n      state.attachmentStates[slot] = attachmentFailed;\n\n      if (node.readiness === 'critical') failCriticalAttachmentStart(scope, state, error);\n      else failDeferredAttachmentStart(instance, attachment, error);\n    },\n  );\n}\n\nfunction startEligibleAttachments(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  state: ScopeGeneration,\n  readiness: 'critical' | 'deferred',\n): void {\n  const scopeNode = requireScopeNode(instance, scope);\n\n  scopeNode.attachmentSlots.forEach((_attachmentSlot, index) => {\n    const slot = index as ScopeAttachmentSlot;\n    const node = requireScopeAttachmentNode(instance, scope, slot);\n\n    if (node.readiness === readiness) startEligibleAttachment(instance, scope, state, slot);\n  });\n}\n\nfunction commitScopeGeneration(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  state: ScopeGeneration,\n): void {\n  if (scope.active !== state || state.phase !== 'opening') return;\n\n  state.phase = 'committing';\n  scope.controller.commit(state.generation);\n\n  if (state.retirement !== undefined) return;\n\n  state.phase = 'ready';\n  startEligibleAttachments(instance, scope, state, 'deferred');\n  releaseOpeningValueIfFullyScheduled(state);\n  state.resolveOpen(readyOpenOutcome);\n}\n\nfunction joinActiveScopeOpen(active: ScopeGeneration, value: unknown): Promise<LocalScopeOpenOutcome> {\n  if ((active.phase === 'committing' || active.phase === 'opening') && Object.is(active.openingValue, value)) {\n    return active.openPromise;\n  }\n\n  throw new TypeError('Local scope is already active or retiring.');\n}\n\nfunction startCriticalAttachments(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  state: ScopeGeneration,\n): void {\n  startEligibleAttachments(instance, scope, state, 'critical');\n\n  if (state.criticalPending === 0) commitScopeGeneration(instance, scope, state);\n}\n\nfunction cleanUpFailedScopeOpen(scope: ScopeInstanceRecord, state: ScopeGeneration, error: unknown): void {\n  state.rejectOpen(error);\n\n  if (state.retirement === undefined) beginScopeRetirement(scope);\n}\n\nfunction beginScopeOpen(\n  instance: ModuleInstanceRecord,\n  scope: ScopeInstanceRecord,\n  value: unknown,\n): Promise<LocalScopeOpenOutcome> {\n  const active = scope.active;\n\n  if (active !== undefined) return joinActiveScopeOpen(active, value);\n\n  const scopeNode = requireScopeNode(instance, scope);\n  scope.attachmentInstances.forEach(attachment => instance.deferredFailures.delete(attachment));\n  const generation = scope.controller.begin();\n  let rejectOpen = (_error: unknown): void => undefined;\n  let resolveOpen = (_outcome: LocalScopeOpenOutcome): void => undefined;\n  const openPromise = new Promise<LocalScopeOpenOutcome>((resolve, reject) => {\n    rejectOpen = reject;\n    resolveOpen = resolve;\n  });\n  const state: ScopeGeneration = {\n    attachmentStates: new Uint8Array(scope.attachmentInstances.length),\n    callbackInvocationDepth: 0,\n    criticalPending: scopeNode.criticalAttachmentSlots.length,\n    failure: undefined,\n    generation,\n    invokeAttachmentCallback: callback => {\n      state.callbackInvocationDepth += 1;\n\n      try {\n        return callback();\n      } finally {\n        state.callbackInvocationDepth -= 1;\n      }\n    },\n    openingValue: value,\n    openPromise,\n    phase: 'opening',\n    rejectOpen,\n    resolveOpen,\n    retirement: undefined,\n    unstartedAttachments: scope.attachmentInstances.length,\n    value: instance.retainScopeValues ? value : undefined,\n  };\n  scope.active = state;\n\n  try {\n    startCriticalAttachments(instance, scope, state);\n  } catch (error) {\n    cleanUpFailedScopeOpen(scope, state, error);\n  }\n\n  return openPromise;\n}\n\nexport { beginScopeOpen, deferredFailureDiagnostics };\n"],"names":["readyOpenOutcome","attachmentPending","attachmentOpening","attachmentReady","attachmentFailed","isReadyOutcome","outcome","isDeferredFailureOutcome","rejectedDeferredFailure","error","settleDeferredAttachment","instance","attachment","deferredFailureDiagnostics","left","right","requireScopeNode","scope","node","requireScopeAttachmentNode","slot","scopeNode","attachmentSlot","requireScopeAttachmentInstance","attachmentPhaseAllowsStart","readiness","phase","failCriticalAttachmentStart","state","reportDetachedError","beginScopeRetirement","retirementError","failDeferredAttachmentStart","releaseOpeningValueIfFullyScheduled","settleReadyAttachment","commitScopeGeneration","settleAttachmentOpen","startEligibleAttachment","value","opening","openOwnerBoundAttachment","startEligibleAttachments","_attachmentSlot","index","joinActiveScopeOpen","active","startCriticalAttachments","cleanUpFailedScopeOpen","beginScopeOpen","generation","rejectOpen","_error","resolveOpen","_outcome","openPromise","resolve","reject","callback"],"mappings":"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"}

package/dist/module-scope-retirement.d.ts

@@ -0,0 +1,3 @@
+import type { RetirementRecord, ScopeInstanceRecord } from './module-instance-types.js';
+declare function beginScopeRetirement(scope: ScopeInstanceRecord): RetirementRecord;
+export { beginScopeRetirement };

package/dist/module-scope-retirement.js

@@ -0,0 +1,2 @@
+import{createAttachmentRetirementScheduler as h}from"./attachment-retirement-scheduler.js";import{retryOwnerBoundAttachmentClose as w}from"./owner-generation.js";import{retirePlannedOwnerGeneration as y,acknowledgeOwnerGenerationDrain as R}from"./owner-generation-retirement.js";const P=Object.freeze({kind:"closed"});function g(e){const n=e.ownerRetirement;if(n===void 0)throw new TypeError("Local scope retirement is already workspace.");return n}function u(e){const n=e.scope;if(n===void 0)throw new TypeError("Local scope retirement is already workspace.");return n}function d(e){const n=e.state;if(n===void 0)throw new TypeError("Local scope retirement is already workspace.");return n}function v(e){const n=g(e),t=u(e),r=d(e);R(t.controller,r.generation,n.attachments,n.retirement),e.drainPromise=void 0,e.ownerRetirement=void 0,e.prepared=void 0,e.retryPromise=void 0,e.scheduler=void 0,t.attachmentInstances.forEach(i=>t.deferredFailures.delete(i)),t.active===r&&(t.active=void 0),r.value=void 0,e.rejectPrepared=()=>{},e.resolvePrepared=()=>{},e.scope=void 0,e.state=void 0,e.handleState.outcome=P,e.handleState.record=void 0}function s(e){const n=e.scheduler;if(n===void 0)throw new TypeError("Retirement scheduler unavailable.");return n}function f(e){if(e.drainPromise===void 0){const n=e.prepared;if(n===void 0)throw new TypeError("Retirement preparation unavailable.");e.drainPromise=n.then(()=>s(e).drain())}return e.drainPromise}function b(e){if(e.retryPromise!==void 0)return e.retryPromise;const n=e.prepared;if(n===void 0)throw new TypeError("Retirement preparation unavailable.");const r=n.then(()=>s(e).retry()).finally(()=>{e.retryPromise===r&&e.handleState.outcome===void 0&&(e.retryPromise=void 0)});return e.retryPromise=r,r}function O(e){const n=e.record;if(n===void 0)throw new TypeError("Retirement record unavailable.");return n}function m(e){const n=O(e);if(d(n).callbackInvocationDepth!==0)throw new TypeError("Local scope retirement cannot be awaited from its synchronous attachment callback.");return n}function E(e){return Object.freeze({drain:()=>e.outcome===void 0?f(m(e)):Promise.resolve(e.outcome),retry:()=>e.outcome===void 0?b(m(e)):Promise.resolve(e.outcome)})}function S(e,n){let t=c=>{},r=()=>{};const i=new Promise((c,l)=>{t=l,r=c}),o={outcome:void 0,record:void 0},a={drainPromise:void 0,handleState:o,ownerRetirement:void 0,prepared:i,rejectPrepared:t,resolvePrepared:r,retryPromise:void 0,runtime:void 0,scheduler:void 0,scope:e,state:n};return o.record=a,a.runtime=E(o),a}function j(e){let n=i=>{},t=()=>{};const r=new Promise((i,o)=>{n=o,t=i});e.drainPromise=void 0,e.prepared=r,e.rejectPrepared=n,e.resolvePrepared=t,e.retryPromise=void 0}function T(e,n){const t=[];let r=0;for(const i of e.attachmentInstances)i.bound===n.attachments[r]&&(t.push(i),r+=1);if(r!==n.attachments.length)throw new TypeError("Owner retirement selected an attachment outside its compiled scope instance.");return Object.freeze(t)}function k(e,n,t){const r=n.retirement.retirements;if(r.length!==t.length)throw new TypeError("Owner retirement lost alignment with the compiled attachment graph.");return h({attachments:t,onTerminal:()=>v(e),retirements:r,retryAttachment:i=>w(i.bound)})}function x(e){const n=d(e);f(e).then(t=>{const r=n.failure;n.openingValue=void 0,r===void 0?n.resolveOpen(Object.freeze({drain:t,kind:"retired",retirement:e.runtime})):n.resolveOpen(Object.freeze({attachmentId:r.attachment.id,attachmentSlot:r.attachment.slot,drain:t,kind:"not-ready",outcome:r.outcome,retirement:e.runtime}))},t=>n.rejectOpen(t))}function p(e){var r;const n=u(e),t=d(e);t.phase="fencing",t.openingValue=void 0;try{const i=e.ownerRetirement??y(n.controller,t.generation,n.attachmentInstances.map(a=>a.bound)),o=T(n,i);e.ownerRetirement=i,e.scheduler=k(e,i,o),t.phase="retiring",e.resolvePrepared()}catch(i){throw t.openingValue=void 0,t.phase="retiring",(r=e.prepared)==null||r.catch(()=>{}),e.rejectPrepared(i),t.rejectOpen(i),i}}function A(e){const n=e.active;if(n===void 0)throw new TypeError("Cannot retire an inactive local scope.");const t=n.retirement;if(t!==void 0)return t.scheduler===void 0&&(j(t),p(t)),t;const r=n.phase==="committing"||n.phase==="opening",i=S(e,n);return n.retirement=i,r&&x(i),p(i),i}export{A as beginScopeRetirement};
+//# sourceMappingURL=module-scope-retirement.js.map

package/dist/module-scope-retirement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-scope-retirement.js","sources":["../src/module-scope-retirement.ts"],"sourcesContent":["import { createAttachmentRetirementScheduler } from './attachment-retirement-scheduler';\nimport type {\n  AttachmentInstance,\n  AttachmentRetirementScheduler,\n  LocalScopeDrainOutcome,\n  LocalScopeRetirement,\n  RetirementHandleState,\n  RetirementRecord,\n  ScopeGeneration,\n  ScopeInstanceRecord,\n} from './module-instance-types';\nimport {\n  acknowledgeOwnerGenerationDrain,\n  retirePlannedOwnerGeneration,\n  retryOwnerBoundAttachmentClose,\n} from './owner-generation';\nimport type { OwnerGenerationPlanRetirement } from './owner-generation';\n\nconst closedDrainOutcome = Object.freeze({ kind: 'closed' as const });\n\nfunction workspaceRetirementRecord(record: RetirementRecord): OwnerGenerationPlanRetirement {\n  const ownerRetirement = record.ownerRetirement;\n\n  if (ownerRetirement === undefined) throw new TypeError('Local scope retirement is already workspace.');\n\n  return ownerRetirement;\n}\n\nfunction retirementScope(record: RetirementRecord): ScopeInstanceRecord {\n  const scope = record.scope;\n\n  if (scope === undefined) throw new TypeError('Local scope retirement is already workspace.');\n\n  return scope;\n}\n\nfunction retirementState(record: RetirementRecord): ScopeGeneration {\n  const state = record.state;\n\n  if (state === undefined) throw new TypeError('Local scope retirement is already workspace.');\n\n  return state;\n}\n\nfunction clearActiveRetirement(record: RetirementRecord): void {\n  const ownerRetirement = workspaceRetirementRecord(record);\n  const scope = retirementScope(record);\n  const state = retirementState(record);\n  acknowledgeOwnerGenerationDrain(\n    scope.controller,\n    state.generation,\n    ownerRetirement.attachments,\n    ownerRetirement.retirement,\n  );\n  record.drainPromise = undefined;\n  record.ownerRetirement = undefined;\n  record.prepared = undefined;\n  record.retryPromise = undefined;\n  record.scheduler = undefined;\n  scope.attachmentInstances.forEach(attachment => scope.deferredFailures.delete(attachment));\n\n  if (scope.active === state) scope.active = undefined;\n\n  state.value = undefined;\n\n  record.rejectPrepared = (): void => undefined;\n  record.resolvePrepared = (): void => undefined;\n  record.scope = undefined;\n  record.state = undefined;\n  record.handleState.outcome = closedDrainOutcome;\n  record.handleState.record = undefined;\n}\n\nfunction preparedRetirementScheduler(record: RetirementRecord): AttachmentRetirementScheduler {\n  const scheduler = record.scheduler;\n\n  if (scheduler === undefined) throw new TypeError('Retirement scheduler unavailable.');\n\n  return scheduler;\n}\n\nfunction drainRetirement(record: RetirementRecord): Promise<LocalScopeDrainOutcome> {\n  if (record.drainPromise === undefined) {\n    const prepared = record.prepared;\n\n    if (prepared === undefined) throw new TypeError('Retirement preparation unavailable.');\n\n    record.drainPromise = prepared.then(() => preparedRetirementScheduler(record).drain());\n  }\n\n  return record.drainPromise;\n}\n\nfunction retryRetirement(record: RetirementRecord): Promise<LocalScopeDrainOutcome> {\n  if (record.retryPromise !== undefined) return record.retryPromise;\n\n  const prepared = record.prepared;\n\n  if (prepared === undefined) throw new TypeError('Retirement preparation unavailable.');\n\n  const operation = prepared.then(() => preparedRetirementScheduler(record).retry());\n  const singleFlight = operation.finally(() => {\n    if (record.retryPromise === singleFlight && record.handleState.outcome === undefined) {\n      record.retryPromise = undefined;\n    }\n  });\n  record.retryPromise = singleFlight;\n\n  return singleFlight;\n}\n\nfunction requireRetirementHandleRecord(state: RetirementHandleState): RetirementRecord {\n  const record = state.record;\n\n  if (record === undefined) throw new TypeError('Retirement record unavailable.');\n\n  return record;\n}\n\nfunction requireExternallyCallableRetirementRecord(state: RetirementHandleState): RetirementRecord {\n  const record = requireRetirementHandleRecord(state);\n\n  if (retirementState(record).callbackInvocationDepth !== 0) {\n    throw new TypeError('Local scope retirement cannot be awaited from its synchronous attachment callback.');\n  }\n\n  return record;\n}\n\nfunction createRetirementRuntime(state: RetirementHandleState): LocalScopeRetirement {\n  return Object.freeze({\n    drain: (): Promise<LocalScopeDrainOutcome> =>\n      state.outcome === undefined\n        ? drainRetirement(requireExternallyCallableRetirementRecord(state))\n        : Promise.resolve(state.outcome),\n    retry: (): Promise<LocalScopeDrainOutcome> =>\n      state.outcome === undefined\n        ? retryRetirement(requireExternallyCallableRetirementRecord(state))\n        : Promise.resolve(state.outcome),\n  }) as LocalScopeRetirement;\n}\n\nfunction createRetirementRecord(scope: ScopeInstanceRecord, state: ScopeGeneration): RetirementRecord {\n  let rejectPrepared = (_error: unknown): void => undefined;\n  let resolvePrepared = (): void => undefined;\n  const prepared = new Promise<void>((resolve, reject) => {\n    rejectPrepared = reject;\n    resolvePrepared = resolve;\n  });\n  const handleState: RetirementHandleState = { outcome: undefined, record: undefined };\n  const record: RetirementRecord = {\n    drainPromise: undefined,\n    handleState,\n    ownerRetirement: undefined,\n    prepared,\n    rejectPrepared,\n    resolvePrepared,\n    retryPromise: undefined,\n    runtime: undefined as unknown as LocalScopeRetirement,\n    scheduler: undefined,\n    scope,\n    state,\n  };\n  handleState.record = record;\n  record.runtime = createRetirementRuntime(handleState);\n\n  return record;\n}\n\nfunction resetRetirementPreparation(record: RetirementRecord): void {\n  let rejectPrepared = (_error: unknown): void => undefined;\n  let resolvePrepared = (): void => undefined;\n  const prepared = new Promise<void>((resolve, reject) => {\n    rejectPrepared = reject;\n    resolvePrepared = resolve;\n  });\n  record.drainPromise = undefined;\n  record.prepared = prepared;\n  record.rejectPrepared = rejectPrepared;\n  record.resolvePrepared = resolvePrepared;\n  record.retryPromise = undefined;\n}\n\nfunction exactAttachmentInstances(\n  scope: ScopeInstanceRecord,\n  planRetirement: OwnerGenerationPlanRetirement,\n): readonly AttachmentInstance[] {\n  const exact: AttachmentInstance[] = [];\n  let selectedIndex = 0;\n\n  for (const attachment of scope.attachmentInstances) {\n    if (attachment.bound !== planRetirement.attachments[selectedIndex]) continue;\n\n    exact.push(attachment);\n    selectedIndex += 1;\n  }\n\n  if (selectedIndex !== planRetirement.attachments.length) {\n    throw new TypeError('Owner retirement selected an attachment outside its compiled scope instance.');\n  }\n\n  return Object.freeze(exact);\n}\n\nfunction createScopeRetirementScheduler(\n  record: RetirementRecord,\n  ownerRetirement: OwnerGenerationPlanRetirement,\n  attachments: readonly AttachmentInstance[],\n): AttachmentRetirementScheduler {\n  const retirements = ownerRetirement.retirement.retirements;\n\n  if (retirements.length !== attachments.length) {\n    throw new TypeError('Owner retirement lost alignment with the compiled attachment graph.');\n  }\n\n  return createAttachmentRetirementScheduler({\n    attachments,\n    onTerminal: () => clearActiveRetirement(record),\n    retirements,\n    retryAttachment: attachment => retryOwnerBoundAttachmentClose(attachment.bound),\n  });\n}\n\nfunction settleOpeningAfterRetirement(record: RetirementRecord): void {\n  const state = retirementState(record);\n\n  void drainRetirement(record).then(\n    drain => {\n      const failure = state.failure;\n      state.openingValue = undefined;\n\n      if (failure === undefined) {\n        state.resolveOpen(Object.freeze({ drain, kind: 'retired' as const, retirement: record.runtime }));\n      } else {\n        state.resolveOpen(\n          Object.freeze({\n            attachmentId: failure.attachment.id,\n            attachmentSlot: failure.attachment.slot,\n            drain,\n            kind: 'not-ready' as const,\n            outcome: failure.outcome,\n            retirement: record.runtime,\n          }),\n        );\n      }\n    },\n    (error: unknown) => state.rejectOpen(error),\n  );\n}\n\nfunction prepareScopeRetirement(retirement: RetirementRecord): void {\n  const scope = retirementScope(retirement);\n  const state = retirementState(retirement);\n  state.phase = 'fencing';\n  state.openingValue = undefined;\n\n  try {\n    const planRetirement =\n      retirement.ownerRetirement ??\n      retirePlannedOwnerGeneration(\n        scope.controller,\n        state.generation,\n        scope.attachmentInstances.map(attachment => attachment.bound),\n      );\n    const exactAttachments = exactAttachmentInstances(scope, planRetirement);\n    retirement.ownerRetirement = planRetirement;\n    retirement.scheduler = createScopeRetirementScheduler(retirement, planRetirement, exactAttachments);\n    state.phase = 'retiring';\n    retirement.resolvePrepared();\n  } catch (error) {\n    state.openingValue = undefined;\n    state.phase = 'retiring';\n    // A synchronous fence failure can make the handle unreachable before drain() observes preparation.\n    void retirement.prepared?.catch(() => undefined);\n    retirement.rejectPrepared(error);\n    state.rejectOpen(error);\n    throw error;\n  }\n}\n\nfunction beginScopeRetirement(scope: ScopeInstanceRecord): RetirementRecord {\n  const state = scope.active;\n\n  if (state === undefined) throw new TypeError('Cannot retire an inactive local scope.');\n\n  const existing = state.retirement;\n\n  if (existing !== undefined) {\n    if (existing.scheduler === undefined) {\n      resetRetirementPreparation(existing);\n      prepareScopeRetirement(existing);\n    }\n\n    return existing;\n  }\n\n  const wasOpening = state.phase === 'committing' || state.phase === 'opening';\n  const retirement = createRetirementRecord(scope, state);\n  state.retirement = retirement;\n\n  if (wasOpening) settleOpeningAfterRetirement(retirement);\n\n  prepareScopeRetirement(retirement);\n\n  return retirement;\n}\n\nexport { beginScopeRetirement };\n"],"names":["closedDrainOutcome","workspaceRetirementRecord","record","ownerRetirement","retirementScope","scope","retirementState","state","clearActiveRetirement","acknowledgeOwnerGenerationDrain","attachment","preparedRetirementScheduler","scheduler","drainRetirement","prepared","retryRetirement","singleFlight","requireRetirementHandleRecord","requireExternallyCallableRetirementRecord","createRetirementRuntime","createRetirementRecord","rejectPrepared","_error","resolvePrepared","resolve","reject","handleState","resetRetirementPreparation","exactAttachmentInstances","planRetirement","exact","selectedIndex","createScopeRetirementScheduler","attachments","retirements","createAttachmentRetirementScheduler","retryOwnerBoundAttachmentClose","settleOpeningAfterRetirement","drain","failure","error","prepareScopeRetirement","retirement","retirePlannedOwnerGeneration","exactAttachments","_a","beginScopeRetirement","existing","wasOpening"],"mappings":"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"}

package/dist/module-template-ir.d.ts

@@ -0,0 +1,59 @@
+import type { DeclarationId } from '@opetope/core';
+declare const attachmentTemplateSlotBrand: unique symbol;
+declare const callTargetBindingSlotBrand: unique symbol;
+declare const compiledModuleTemplateBrand: unique symbol;
+declare const scopeAttachmentSlotBrand: unique symbol;
+declare const scopeTemplateSlotBrand: unique symbol;
+type AttachmentTemplateSlot = number & {
+    readonly [attachmentTemplateSlotBrand]: true;
+};
+type CallTargetBindingSlot = number & {
+    readonly [callTargetBindingSlotBrand]: true;
+};
+type ScopeAttachmentSlot = number & {
+    readonly [scopeAttachmentSlotBrand]: true;
+};
+type ScopeTemplateSlot = number & {
+    readonly [scopeTemplateSlotBrand]: true;
+};
+interface RuntimeNodeIdentityIR {
+    readonly id: DeclarationId;
+    readonly key: string;
+    readonly kind: 'attachment' | 'scope';
+    readonly moduleId: DeclarationId;
+    readonly stage: 'runtime';
+}
+interface AttachmentNodeIR {
+    readonly identity: RuntimeNodeIdentityIR & {
+        readonly kind: 'attachment';
+    };
+    readonly ownerScopeSlot: ScopeTemplateSlot;
+    readonly readiness: 'critical' | 'deferred';
+    readonly scopeAttachmentSlot: ScopeAttachmentSlot;
+    readonly slot: AttachmentTemplateSlot;
+}
+interface ScopeNodeIR {
+    readonly attachmentSlots: readonly AttachmentTemplateSlot[];
+    readonly criticalAttachmentSlots: readonly AttachmentTemplateSlot[];
+    readonly identity: RuntimeNodeIdentityIR & {
+        readonly kind: 'scope';
+    };
+    readonly slot: ScopeTemplateSlot;
+}
+interface CallTargetBindingIR {
+    readonly id: DeclarationId;
+    readonly key: string;
+    readonly kind: 'call-target-binding';
+    readonly moduleId: DeclarationId;
+    readonly slot: CallTargetBindingSlot;
+    readonly stage: 'runtime';
+    readonly withinAttachmentSlot: AttachmentTemplateSlot;
+}
+interface CompiledModuleTemplateIR {
+    readonly attachments: readonly AttachmentNodeIR[];
+    readonly callTargetBindings: readonly CallTargetBindingIR[];
+    readonly [compiledModuleTemplateBrand]: true;
+    readonly moduleId: DeclarationId;
+    readonly scopes: readonly ScopeNodeIR[];
+}
+export type { AttachmentNodeIR, AttachmentTemplateSlot, CallTargetBindingIR, CallTargetBindingSlot, CompiledModuleTemplateIR, RuntimeNodeIdentityIR, ScopeAttachmentSlot, ScopeNodeIR, ScopeTemplateSlot, };