@prisma/composer 0.1.0 → 0.2.0-dev.2

package/dist/app-config-BPb3LCdH-CH7b8Khi.d.mts

@@ -0,0 +1,411 @@
+import { A as ProvisionNeed, H as ServiceNode, N as ResourceNode, S as NodeId, d as Graph, n as Config, t as BuildAdapter, y as ModuleNode } from "./graph-types-BcbVhojU-C3fhxjPK.mjs";
+import "./graph-DUSgjmzA-DhtkTqoz.mjs";
+import * as Alchemy from "alchemy";
+import { Input, StackServices } from "alchemy";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { State } from "alchemy/State/State";
+//#region ../../0-framework/1-core/core/dist/app-config-BPb3LCdH.d.mts
+//#region src/container-transport.d.ts
+/**
+ * Carries resolved containers from the CLI process into the alchemy process
+ * (ADR-0037). A deploy runs as two processes: the CLI resolves each
+ * extension's containers, then spawns `alchemy`, which re-imports the config
+ * from scratch and needs those containers back — and env vars are the only
+ * channel between the two. So the CLI writes each instance's `serialize()`
+ * output into one env var per extension, and in the alchemy process
+ * `deserializeContainers` reads each var back through the same extension's
+ * descriptor. The framework owns the vars; it never reads their contents.
+ */
+/** The key an extension resolves a container from: which app, which stage. */
+interface LocateContainerInput {
+  /** The application name (root node's name, or `--name`). */
+  readonly appName: string;
+  /** The named stage, or `undefined` for the default (production) stage. */
+  readonly stage: string | undefined;
+}
+/**
+ * One resolved container. The framework sees only this interface; the
+ * extension that produced the instance narrows it back to its own concrete
+ * type wherever the framework hands it back (ADR-0037).
+ */
+interface ContainerInstance {
+  readonly input: LocateContainerInput;
+  /** Serialize to a non-empty string for the process transport above. The format is the extension's own; only its `deserialize` reads it. */
+  serialize(): string;
+}
+/**
+ * The platform containers an app deploys into, as one lifecycle. `I` is
+ * the extension's own instance type — the same descriptor produces and
+ * consumes it, so the extension gets full typing internally while the
+ * framework stores the erased form. METHOD SYNTAX REQUIRED on all four
+ * members: the erased assignment into ExtensionDescriptor compiles only
+ * through method bivariance; property-arrow members are checked
+ * contravariantly and the assignment fails (same rule as
+ * ServiceLowering<P, S> — ADR-0033).
+ */
+interface ContainerDescriptor<I extends ContainerInstance = ContainerInstance> {
+  /** Resolve the container for (appName, stage), creating anything absent. Called by `deploy`. */
+  ensure(input: LocateContainerInput): Promise<I>;
+  /** Find the container for (appName, stage); `undefined` when nothing exists. Called by `destroy` — never creates. */
+  locate(input: LocateContainerInput): Promise<I | undefined>;
+  /** Remove the container after a successful destroy, after every extension's `teardown` has run. Failure policy is the extension's. */
+  remove(instance: I): Promise<void>;
+  /** Reconstruct an instance from its own `serialize()` output — the far end of the framework's parent→child transport. */
+  deserialize(serialized: string): I;
+}
+/** '@prisma/composer-prisma-cloud' → 'PRISMA_COMPOSER_CONTAINER_PRISMA_COMPOSER_PRISMA_CLOUD' */
+declare function containerEnvVarName(extensionId: string): string;
+/** The env entries the CLI sets on the alchemy process: `{ [containerEnvVarName(id)]: instance.serialize() }` for every resolved instance. */
+declare function containerEnv(instances: ReadonlyMap<string, ContainerInstance>): Record<string, string>;
+/** The slice of `PrismaAppConfig.extensions` this module needs — kept narrow so this shared-plane module never imports the control-plane `ExtensionDescriptor`/`PrismaAppConfig` types (ADR-0028's plane split). */
+interface ContainerTransportExtension {
+  readonly id: string;
+  readonly container?: ContainerDescriptor;
+}
+/**
+ * The alchemy-process side: for each extension with a container descriptor
+ * whose var is present in `env`, call its deserialize. Absent var → no entry.
+ */
+declare function deserializeContainers(extensions: readonly ContainerTransportExtension[], env: Readonly<Record<string, string | undefined>>): ReadonlyMap<string, ContainerInstance>;
+//#endregion
+//#region src/control/deploy.d.ts
+/** The Layer shape every Alchemy state store must satisfy — what `LowerOptions.state` and `PrismaAppConfig.state` both traffic in. */
+type AlchemyStateLayer = Layer.Layer<State, never, StackServices>;
+/**
+ * An extension's application-level descriptor: shared infrastructure that runs
+ * once per lowering, before any node. Its outputs reach the extension's own
+ * SPI calls via LowerContext.application.
+ */
+interface ApplicationDescriptor {
+  provision(ctx: LowerContext): Effect.Effect<unknown, unknown, unknown>;
+}
+/**
+ * One provisioned param need, resolved against the CONSUMER extension's
+ * `provisions` registry (ADR-0031). `edgeId` — `${consumerAddress}.${input}`
+ * — is the mint's stable resource key, so a provisioner's own resource ids
+ * derive from it and stay stable across redeploys.
+ */
+interface ProvisionEdge {
+  readonly edgeId: string;
+  readonly consumerAddress: string;
+  readonly providerAddress: string;
+  readonly input: string;
+  /** Opaque; forwarded from the param's declared need. Core never reads its payload. */
+  readonly need: ProvisionNeed;
+}
+/** One extension-registered provisioner, keyed by a need's brand (ADR-0031). */
+interface ProvisionerDescriptor {
+  /** Mints one stable value for one provisioned edge; yields the platform resource, returns an opaque ref core forwards into config. */
+  provision(edge: ProvisionEdge): Effect.Effect<unknown, unknown, unknown>;
+}
+/**
+ * The phased service SPI. `P` and `S` are the descriptor's OWN intra-node
+ * handoff types — provision's product consumed by serialize/deploy, and
+ * serialize's product consumed by deploy. Core threads them through without
+ * inspection; only the descriptor that writes them reads them.
+ *
+ * Method syntax (not property-arrow) is required: the heterogeneous
+ * descriptor registry (`NodeDescriptor`) assigns concrete descriptors to
+ * this interface's `unknown` defaults through TypeScript's method
+ * bivariance — a property-arrow form is checked contravariantly and breaks
+ * that assignment.
+ */
+interface ServiceLowering<P = unknown, S = unknown> {
+  /** Makes the platform-specific thing that will host the service — identity-bearing infrastructure only, no code runs. */
+  provision(ctx: LowerContext): Effect.Effect<P, unknown, unknown>;
+  /**
+   * Encodes the typed Config into the service's runtime environment. Boot-side
+   * deserialize reverses it through the same serializer. Returns the env-var
+   * records so `deploy` can reference them.
+   */
+  serialize(ctx: LowerContext, provisioned: P, config: Config): Effect.Effect<S, unknown, unknown>;
+  /**
+   * Prints the bootstrap and assembles the deployable artifact from the
+   * app-built bundle. Must be byte-deterministic: an unchanged service noops
+   * on redeploy.
+   */
+  package(ctx: LowerContext, input: PackageInput): Effect.Effect<Artifact, unknown, unknown>;
+  /** Ships the packaged artifact into the provisioned thing and runs it. Returns the node's outputs for dependents, plus the entities it became on the deployment target. */
+  deploy(ctx: LowerContext, provisioned: P, artifact: Artifact, serialized: S): Effect.Effect<LoweredResult, unknown, unknown>;
+}
+/** Input to an extension's package() step: the built bundle and the node's graph address. */
+interface PackageInput {
+  /** The build descriptor's normalized output: the bundle dir + the app's runnable. */
+  readonly assembled: Bundle;
+  /** The node's graph address — baked into the printed bootstrap. */
+  readonly address: string;
+}
+/** One node's realization. Runs inside the Alchemy stack effect. */
+type Lowering = (ctx: LowerContext) => Effect.Effect<LoweredResult, unknown, unknown>;
+interface LowerContext {
+  readonly id: NodeId;
+  /**
+   * The node's deployment address: its full, dot-joined hierarchical
+   * position in the graph (e.g. "auth.api"). The config-key namespace and
+   * the bootstrap parameter.
+   */
+  readonly address: string;
+  readonly node: ServiceNode | ResourceNode;
+  readonly graph: Graph;
+  readonly opts: LowerOptions;
+  /**
+   * The owning extension's application hook product; `undefined` when the
+   * extension declares no hook. Core never reads it; the extension narrows
+   * it with its own type guard.
+   */
+  readonly application: unknown;
+  /**
+   * The owning extension's resolved container, deserialized from the
+   * framework transport; core never reads it — the extension narrows it
+   * with its own type guard. `undefined` when the extension declares no
+   * container descriptor.
+   */
+  readonly container: ContainerInstance | undefined;
+  /** Already-lowered deps (topo order). */
+  readonly lowered: ReadonlyMap<NodeId, Outputs>;
+  /** Every provisioned param value minted this lowering, keyed by edge id (ADR-0031). */
+  readonly provisioned: ReadonlyMap<string, unknown>;
+}
+/**
+ * The values a node provides to its dependents — what a consumer's declared
+ * connection params resolve against (buildConfig reads them by param name).
+ * Name-keyed and unknown-valued of necessity: core cannot know extension
+ * types, and which producer feeds which consumer is decided by the user's
+ * graph at runtime. The connection declaration is the contract.
+ */
+type Outputs = Readonly<Record<string, unknown>>;
+/**
+ * One thing a node became on the deployment target, RESOLVED — what the report
+ * consumer sees. The descriptor names it; core never infers meaning from it.
+ * `url` is present ONLY when the descriptor declares the address publicly
+ * reachable — a connection string is never a `url`.
+ *
+ * A descriptor constructing one holds `svc.id` / `deployment.deployedUrl` —
+ * `Output<T>` references, not values, because the stack effect runs before
+ * Alchemy applies anything. So construction sites traffic in
+ * `Input<DeployedEntity>` (Alchemy's own idiom for "this shape, fields possibly
+ * unresolved"); apply resolves it before any reader sees it.
+ */
+interface DeployedEntity {
+  readonly kind: string;
+  readonly id: string;
+  readonly url?: string;
+  readonly details?: Readonly<Record<string, string>>;
+}
+/**
+ * What a node's final lowering phase produces: outputs for dependents,
+ * entities for reporting.
+ *
+ * `entities` is REQUIRED, not optional. "This node became nothing reportable
+ * on the deployment target" is a claim, and an optional field lets a
+ * descriptor make it by saying nothing at all — no error, no type complaint,
+ * no failing test. That is the shared bag's sin in miniature (ADR-0033): a
+ * claim made anonymously, with nothing recording that a claim was made. `[]`
+ * costs one token and puts the assertion on the record where a reviewer can
+ * see it.
+ */
+interface LoweredResult {
+  readonly outputs: Outputs;
+  readonly entities: readonly Input<DeployedEntity>[];
+}
+/** What one graph node became — in-process only (it holds the node itself, so it never crosses the stack boundary). */
+interface DeployedNode {
+  readonly address: string;
+  readonly node: ServiceNode | ResourceNode;
+  readonly entities: readonly DeployedEntity[];
+}
+/** The result of the Deploy operation: the app and every node it deployed, in topo order. */
+interface DeploymentResult {
+  readonly app: string;
+  readonly nodes: readonly DeployedNode[];
+}
+interface LowerOptions {
+  /** Stack + root node id. */
+  readonly name: string;
+  readonly bundles: Record<string, Bundle>;
+  readonly stage?: string;
+  /** Alchemy state store for the stack. Defaults to the config's own state layer. */
+  readonly state?: AlchemyStateLayer;
+  /**
+   * Invoked once per deploy, during apply, with the Deploy operation's result
+   * — the app and every node it deployed, resolved, in topo order.
+   * Presentation belongs to the caller (the CLI wires its renderer here);
+   * core never formats. Absent means no report is assembled and no Action is
+   * declared at all.
+   */
+  readonly report?: (result: DeploymentResult) => void;
+}
+/** A build descriptor's normalized output: the produced bundle dir plus the app's runnable entry within it. */
+interface Bundle {
+  readonly dir: string;
+  readonly entry: string;
+}
+/** Shared input shape for every extension's build descriptor. */
+interface AssembleInput {
+  readonly build: BuildAdapter;
+  /** The service's graph address (e.g. "storefront.web"). Unique per service, so the assembler uses it to name this service's own working directory: `<cwd>/.prisma-composer/artifacts/<address>/`. */
+  readonly address: string;
+  /** The directory the deploy command was run from. The assembler puts its working directory under it (`<cwd>/.prisma-composer/`), the same place the CLI writes its other generated files. */
+  readonly cwd: string;
+}
+/** package()'s product. */
+interface Artifact {
+  readonly path: string;
+  readonly sha256: string;
+}
+declare class LowerError extends Error {
+  constructor(message: string);
+}
+/**
+ * Assembles a service's typed Config. Connection params come from the
+ * dependency edge's lowered outputs — or, for a param carrying a `provision`
+ * need (ADR-0031), from `provisioned` (keyed by edge id): the framework mints
+ * it, the producer hands nothing over. The service's own params resolve via
+ * `resolveParam` (provision-time binding, then default, then loud
+ * unbound-required failure).
+ *
+ * This is also where the connection contract is enforced: a producer that fails to
+ * supply a required param its consumer's connection declares fails the deploy
+ * here, naming the edge, rather than reaching the consumer as `undefined`.
+ */
+declare function buildConfig(node: ServiceNode, id: NodeId, graph: Graph, lowered: ReadonlyMap<NodeId, Outputs>, provisioned: ReadonlyMap<string, unknown>): Config;
+/**
+ * Joins resolved report entries back to their graph nodes — the last step of a
+ * deploy report, run inside the Action with apply's resolved values.
+ *
+ * The entries cross Alchemy's action-input boundary, so they carry addresses
+ * and plain entities only; the graph is held by closure on this side. That
+ * split is why this join exists at all, and it is what keeps functions and
+ * Standard Schemas (which a node carries, and which the plan's input hash
+ * would have to serialize) out of the input.
+ *
+ * Skips an address the graph no longer holds: entries are data, the graph is
+ * truth.
+ */
+declare function joinDeployment(graph: Graph, entries: readonly {
+  address: string;
+  entities: readonly DeployedEntity[];
+}[]): readonly DeployedNode[];
+/**
+ * The state-layer precedence a deploy resolves to: an explicit opts.state
+ * always wins; failing that, the config's own (required) state descriptor,
+ * created with its owning extension's resolved container (`undefined` when
+ * that extension declared none). A pure function so the precedence is
+ * testable without booting Alchemy.
+ */
+declare function resolveStateLayer(opts: LowerOptions, config: PrismaAppConfig, containers: ReadonlyMap<string, ContainerInstance>): AlchemyStateLayer;
+/**
+ * All configured extensions' providers merged, config array order — an
+ * extension without `providers` is skipped; no used-extensions-only
+ * filtering (ADR-0017's pinned providers rule).
+ */
+declare function mergedProviders(config: PrismaAppConfig): Layer.Layer<never>;
+/**
+ * Composable form for mixed stacks: hand-wired Alchemy resources alongside Prisma App nodes in one stack effect.
+ * Fails with LowerError or whatever an extension's lowering raises — the error type is open.
+ */
+declare function lowering(root: ModuleNode, config: PrismaAppConfig, opts: LowerOptions): Effect.Effect<undefined, LowerError, unknown>;
+/**
+ * The whole-stack wrapper: Load → route each node through the config's
+ * extension registries → an Alchemy Stack (the default export the alchemy
+ * CLI consumes).
+ */
+declare function lower(root: ModuleNode, config: PrismaAppConfig, opts: LowerOptions): Effect.Effect<Alchemy.CompiledStack<undefined, any>, import("effect/Config").ConfigError, never>;
+//#endregion
+//#region src/control/app-config.d.ts
+/**
+ * One extension's control-plane registry: everything the deploy pipeline may
+ * look up for a node whose `extension` field names this package. `nodes` is
+ * keyed by the node's within-extension ID (`node.type` / `build.type`).
+ */
+interface ExtensionDescriptor {
+  /** The extension's package name, e.g. "@prisma/composer-prisma-cloud" — what a node's `extension` field is matched against. */
+  readonly id: string;
+  /** ONE registry per extension, keyed by node ID. */
+  readonly nodes: Record<string, NodeDescriptor>;
+  /** Param provisioners this extension supplies, keyed by need brand (ADR-0031). Core resolves a param's ProvisionNeed against the CONSUMER extension's map. */
+  readonly provisions?: ReadonlyMap<symbol, ProvisionerDescriptor>;
+  /** Once-per-lowering hook — the application's shared infrastructure (e.g. prisma-cloud's Project). */
+  readonly application?: ApplicationDescriptor;
+  /** The extension's Alchemy providers — merged across all configured extensions (config order). */
+  readonly providers?: () => Layer.Layer<never>;
+  /**
+   * Deploy-time prerequisite check — the CLI runs it once, after the app's
+   * Project/Branch are resolved and BEFORE any stack file is written or Alchemy
+   * runs. A target uses it to verify platform prerequisites (e.g. that every
+   * secret env var in the provision manifest exists for the resolved stage) and
+   * throws to abort the deploy. Async: it talks to the platform (ADR-0029).
+   */
+  readonly preflight?: (input: PreflightInput) => Promise<void>;
+  /**
+   * Destroy-time cleanup — the CLI runs it once, after `alchemy destroy`
+   * succeeds and BEFORE the stage's Project/Branch are removed. A target uses
+   * it to remove infrastructure it owns outside the stack (e.g. the deploy
+   * state store, which the destroy above was still reading). Throwing aborts
+   * the destroy before the containers go; a target that would rather warn than
+   * fail the command handles that itself. Async: it talks to the platform.
+   */
+  readonly teardown?: (input: TeardownInput) => Promise<void>;
+  /**
+   * The extension's container lifecycle, when its platform has containers
+   * (ADR-0038). The CLI resolves containers after assembly and before any
+   * stack file or Alchemy run (deploy ensures, destroy locates); the
+   * resolved instance reaches the alchemy process through the env transport
+   * in container-transport.ts.
+   */
+  readonly container?: ContainerDescriptor;
+}
+/**
+ * The deploy's one state store. It names its owning extension so core knows
+ * whose resolved container to pass into `create` (ADR-0038).
+ */
+interface StateDescriptor {
+  /** The owning extension's id — matched against `ExtensionDescriptor.id`. */
+  readonly extension: string;
+  /** Build the state layer. `container` is the owning extension's resolved instance; `undefined` when it declared no container descriptor. */
+  create(container: ContainerInstance | undefined): AlchemyStateLayer;
+}
+/** The resolved deploy context handed to an extension's `preflight` hook. */
+interface PreflightInput {
+  /** The loaded application graph — the manifest of prerequisites is read from it (`provisionManifest`). */
+  readonly graph: Graph;
+  /** The calling extension's own resolved container; `undefined` when it declares no container descriptor. Narrow with the extension's guard. */
+  readonly container: ContainerInstance | undefined;
+  /** The stage name (`--stage`), or `undefined` for the default stage — for diagnostics/scope. */
+  readonly stage: string | undefined;
+}
+/** The resolved destroy context handed to an extension's `teardown` hook. */
+interface TeardownInput {
+  /** The calling extension's own resolved container; `undefined` when it declares no container descriptor. Narrow with the extension's guard. */
+  readonly container: ContainerInstance | undefined;
+  /** The stage name (`--stage`), or `undefined` for the default stage — for diagnostics/scope. */
+  readonly stage: string | undefined;
+}
+/**
+ * What one registry entry can do. The `kind` discriminant is checked at every
+ * lookup site against what the site needs — a resource node looked up against
+ * a `service` descriptor is an error naming (extension, type, expected kind).
+ */
+type NodeDescriptor = ({
+  readonly kind: 'resource';
+} & Lowering) | ({
+  readonly kind: 'service';
+} & ServiceLowering) | {
+  readonly kind: 'build';
+  assemble(input: AssembleInput): Promise<Bundle>;
+};
+/**
+ * The config file's default export. `extensions` lists every extension the
+ * app deploys through; `state` is the ONE state store per deploy — explicit,
+ * platform-agnostic, never defaulted by an extension.
+ */
+interface PrismaAppConfig {
+  readonly extensions: ExtensionDescriptor[];
+  readonly state: StateDescriptor;
+}
+/** Typed identity — exists so `prisma-composer.config.ts` gets checked against PrismaAppConfig where it is written. */
+declare function defineConfig(config: PrismaAppConfig): PrismaAppConfig;
+//#endregion
+export { containerEnvVarName as A, ProvisionEdge as C, TeardownInput as D, StateDescriptor as E, lowering as F, mergedProviders as I, resolveStateLayer as L, deserializeContainers as M, joinDeployment as N, buildConfig as O, lower as P, PrismaAppConfig as S, ServiceLowering as T, Lowering as _, Bundle as a, PackageInput as b, DeployedEntity as c, ExtensionDescriptor as d, LocateContainerInput as f, LoweredResult as g, LowerOptions as h, AssembleInput as i, defineConfig as j, containerEnv as k, DeployedNode as l, LowerError as m, ApplicationDescriptor as n, ContainerDescriptor as o, LowerContext as p, Artifact as r, ContainerInstance as s, AlchemyStateLayer as t, DeploymentResult as u, NodeDescriptor as v, ProvisionerDescriptor as w, PreflightInput as x, Outputs as y };
+//# sourceMappingURL=app-config-BPb3LCdH-CH7b8Khi.d.mts.map

package/dist/app-config-BPb3LCdH-CH7b8Khi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-config-BPb3LCdH-CH7b8Khi.d.mts","names":[],"sources":["../../../0-framework/1-core/core/dist/app-config-BPb3LCdH.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAmBU;;WAEC;;WAEA;;;;;;;UAOD;WACC,OAAO;;EAEhB;;;;;;;;;;;;UAYQ,oBAAoB,UAAU,oBAAoB;;EAE1D,OAAO,OAAO,uBAAuB,QAAQ;;EAE7C,OAAO,OAAO,uBAAuB,QAAQ;;EAE7C,OAAO,UAAU,IAAI;;EAErB,YAAY,qBAAqB;;;iBAGlB,oBAAoB;;iBAEpB,aAAa,WAAW,oBAAoB,qBAAqB;;UAExE;WACC;WACA,YAAY;;;;;;iBAMN,sBAAsB,qBAAqB,+BAA+B,KAAK,SAAS,sCAAsC,oBAAoB;;;;KAI9J,oBAAoB,MAAM,MAAM,cAAc;;;;;;UAMzC;EACR,UAAU,KAAK,eAAe,OAAO;;;;;;;;UAQ7B;WACC;WACA;WACA;WACA;;WAEA,MAAM;;;UAGP;;EAER,UAAU,MAAM,gBAAgB,OAAO;;;;;;;;;;;;;;UAc/B,gBAAgB,aAAa;;EAErC,UAAU,KAAK,eAAe,OAAO,OAAO;;;;;;EAM5C,UAAU,KAAK,cAAc,aAAa,GAAG,QAAQ,SAAS,OAAO,OAAO;;;;;;EAM5E,QAAQ,KAAK,cAAc,OAAO,eAAe,OAAO,OAAO;;EAE/D,OAAO,KAAK,cAAc,aAAa,GAAG,UAAU,UAAU,YAAY,IAAI,OAAO,OAAO;;;UAGpF;;WAEC,WAAW;;WAEX;;;KAGN,YAAY,KAAK,iBAAiB,OAAO,OAAO;UAC3C;WACC,IAAI;;;;;;WAMJ;WACA,MAAM,cAAc;WACpB,OAAO;WACP,MAAM;;;;;;WAMN;;;;;;;WAOA,WAAW;;WAEX,SAAS,YAAY,QAAQ;;WAE7B,aAAa;;;;;;;;;KASnB,UAAU,SAAS;;;;;;;;;;;;;UAad;WACC;WACA;WACA;WACA,UAAU,SAAS;;;;;;;;;;;;;;UAcpB;WACC,SAAS;WACT,mBAAmB,MAAM;;;UAG1B;WACC;WACA,MAAM,cAAc;WACpB,mBAAmB;;;UAGpB;WACC;WACA,gBAAgB;;UAEjB;;WAEC;WACA,SAAS,eAAe;WACxB;;WAEA,QAAQ;;;;;;;;WAQR,UAAU,QAAQ;;;UAGnB;WACC;WACA;;;UAGD;WACC,OAAO;;WAEP;;WAEA;;;UAGD;WACC;WACA;;cAEG,mBAAmB;EAC/B,YAAY;;;;;;;;;;;;;;iBAcG,YAAY,MAAM,aAAa,IAAI,QAAQ,OAAO,OAAO,SAAS,YAAY,QAAQ,UAAU,aAAa,+BAA+B;;;;;;;;;;;;;;iBAc5I,eAAe,OAAO,OAAO;EAC5C;EACA,mBAAmB;eACN;;;;;;;;iBAQE,kBAAkB,MAAM,cAAc,QAAQ,iBAAiB,YAAY,oBAAoB,qBAAqB;;;;;;iBAMpH,gBAAgB,QAAQ,kBAAkB,MAAM;;;;;iBAKhD,SAAS,MAAM,YAAY,QAAQ,iBAAiB,MAAM,eAAe,OAAO,kBAAkB;;;;;;iBAMlG,MAAM,MAAM,YAAY,QAAQ,iBAAiB,MAAM,eAAe,OAAO,OAAO,QAAQ,uDAAuD;;;;;;;;UAQ1J;;WAEC;;WAEA,OAAO,eAAe;;WAEtB,aAAa,oBAAoB;;WAEjC,cAAc;;WAEd,kBAAkB,MAAM;;;;;;;;WAQxB,aAAa,OAAO,mBAAmB;;;;;;;;;WASvC,YAAY,OAAO,kBAAkB;;;;;;;;WAQrC,YAAY;;;;;;UAMb;;WAEC;;EAET,OAAO,WAAW,gCAAgC;;;UAG1C;;WAEC,OAAO;;WAEP,WAAW;;WAEX;;;UAGD;;WAEC,WAAW;;WAEX;;;;;;;KAON;WACM;IACP;WACO;IACP;WACO;EACT,SAAS,OAAO,gBAAgB,QAAQ;;;;;;;UAOhC;WACC,YAAY;WACZ,OAAO;;;iBAGD,aAAa,QAAQ,kBAAkB"}

package/dist/assertions.d.mts

@@ -25,7 +25,7 @@ declare function assertDefined<T>(value: T | null | undefined, message: string):
  * invariant(edges.length > 0, 'A wired module must have at least one connection');
  * ```
  */
-declare function invariant(condition: boolean, message: string): asserts condition; //#endregion
+declare function invariant(condition: boolean, message: string): asserts condition;
 //#endregion
 export { assertDefined, invariant };
 //# sourceMappingURL=assertions.d.mts.map

package/dist/assertions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.mts","names":[],"sources":["../../../0-framework/0-foundation/foundation/dist/assertions.d.mts"],"mappings":";;;;;;;;;;;;;;;iBAciB,cAAc,GAAG,OAAO,sBAAsB,0BAA0B,SAAS;;;;;;;;;;;;iBAYjF,UAAU,oBAAoB,0BAA0B"}