@composurecdk/core 0.1.0

package/dist/builder.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Constructs an instance of `T`.
+ */
+type Constructor<T> = new () => T;
+/**
+ * Constrains `T` to have a mutable `props` property of type `Props`.
+ * Classes used with {@link Builder} must expose their configuration this way.
+ */
+interface ObjectWithProps<Props extends object> {
+    props: Partial<Props>;
+}
+/**
+ * A fluent builder interface generated from a props type and a target class.
+ *
+ * For each key in `Props`, the builder exposes an overloaded method:
+ * - Called with an argument: sets the prop value and returns the builder for chaining.
+ * - Called with no arguments: returns the current prop value.
+ *
+ * Methods from `T` that return `T` (chainable methods) have their return type
+ * replaced to return the builder. All other members of `T` pass through as-is,
+ * allowing methods like `build()` to be called directly on the builder.
+ *
+ * @typeParam Props - The configurable properties.
+ * @typeParam T - The target class the builder wraps.
+ */
+export type IBuilder<Props extends object, T> = {
+    [K in keyof Props]-?: ((arg: Props[K]) => IBuilder<Props, T>) & (() => Props[K]);
+} & {
+    [K in keyof T]: T[K] extends (...args: infer A) => T ? (...args: A) => IBuilder<Props, T> : T[K];
+};
+/**
+ * Creates a fluent builder wrapping an instance of `T`.
+ *
+ * The builder is backed by a {@link Proxy} that intercepts property access:
+ * - For keys in `Props`: returns a getter/setter function. When called with a
+ *   value, it sets the prop and returns the builder. When called with no args,
+ *   it returns the current value.
+ * - For methods on `T` that return `T`: wraps them to return the builder instead.
+ * - For all other members: delegates directly to the underlying instance.
+ *
+ * @param constructor - The class to instantiate and wrap.
+ * @returns A fluent {@link IBuilder} wrapping a new instance of `T`.
+ */
+export declare function Builder<Props extends object, T extends ObjectWithProps<Props>>(constructor: Constructor<T>): IBuilder<Props, T>;
+export {};
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,WAAW,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC;AAElC;;;GAGG;AACH,UAAU,eAAe,CAAC,KAAK,SAAS,MAAM;IAC5C,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,IAAI;KAC7C,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;CACjF,GAAG;KACD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACjG,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,KAAK,SAAS,MAAM,EAAE,CAAC,SAAS,eAAe,CAAC,KAAK,CAAC,EAC5E,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,GAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAoCpB"}

package/dist/builder.js

@@ -0,0 +1,42 @@
+/**
+ * Creates a fluent builder wrapping an instance of `T`.
+ *
+ * The builder is backed by a {@link Proxy} that intercepts property access:
+ * - For keys in `Props`: returns a getter/setter function. When called with a
+ *   value, it sets the prop and returns the builder. When called with no args,
+ *   it returns the current value.
+ * - For methods on `T` that return `T`: wraps them to return the builder instead.
+ * - For all other members: delegates directly to the underlying instance.
+ *
+ * @param constructor - The class to instantiate and wrap.
+ * @returns A fluent {@link IBuilder} wrapping a new instance of `T`.
+ */
+export function Builder(constructor) {
+    const instance = new constructor();
+    const methods = new Set(Object.getOwnPropertyNames(Object.getPrototypeOf(instance)).filter((key) => key !== "constructor" && typeof instance[key] === "function"));
+    const proxy = new Proxy(instance, {
+        get(target, prop) {
+            if (typeof prop === "symbol") {
+                return Reflect.get(target, prop);
+            }
+            // Props getter/setter
+            if (!methods.has(prop)) {
+                return (...args) => {
+                    if (args.length === 0) {
+                        return target.props[prop];
+                    }
+                    target.props[prop] = args[0];
+                    return proxy;
+                };
+            }
+            // Method on target — wrap to return proxy for chainable methods
+            const method = target[prop];
+            return (...args) => {
+                const result = method.apply(target, args);
+                return result === target ? proxy : result;
+            };
+        },
+    });
+    return proxy;
+}
+//# sourceMappingURL=builder.js.map

package/dist/builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,OAAO,CACrB,WAA2B;IAE3B,MAAM,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAC;IACnC,MAAM,OAAO,GAAG,IAAI,GAAG,CACrB,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAChE,CAAC,GAAG,EAAE,EAAE,CACN,GAAG,KAAK,aAAa,IAAI,OAAQ,QAAoC,CAAC,GAAG,CAAC,KAAK,UAAU,CAC5F,CACF,CAAC;IAEF,MAAM,KAAK,GAAuB,IAAI,KAAK,CAAC,QAAQ,EAAE;QACpD,GAAG,CAAC,MAAS,EAAE,IAAqB;YAClC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC7B,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAY,CAAC;YAC9C,CAAC;YAED,sBAAsB;YACtB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvB,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE;oBAC5B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACtB,OAAO,MAAM,CAAC,KAAK,CAAC,IAAmB,CAAC,CAAC;oBAC3C,CAAC;oBACD,MAAM,CAAC,KAAK,CAAC,IAAmB,CAAC,GAAG,IAAI,CAAC,CAAC,CAAuB,CAAC;oBAClE,OAAO,KAAK,CAAC;gBACf,CAAC,CAAC;YACJ,CAAC;YAED,gEAAgE;YAChE,MAAM,MAAM,GAAI,MAAkC,CAAC,IAAI,CAAiC,CAAC;YACzF,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE;gBAC5B,MAAM,MAAM,GAAY,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBACnD,OAAO,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;YAC5C,CAAC,CAAC;QACJ,CAAC;KACF,CAAuB,CAAC;IAEzB,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/compose.d.ts

@@ -0,0 +1,93 @@
+import { type IConstruct } from "constructs";
+import { type Lifecycle } from "./lifecycle.js";
+import { type StackStrategy } from "./stack-strategy.js";
+/**
+ * Maps a record of {@link Lifecycle} components to a record of their build outputs.
+ * Each property's type is derived from the return type of the corresponding
+ * component's `build` method, preserving full type information through composition.
+ *
+ * @typeParam T - A record where every value implements {@link Lifecycle}.
+ */
+type BuildResult<T extends {
+    [Property in keyof T]: Lifecycle;
+}> = {
+    [Property in keyof T]: ReturnType<T[Property]["build"]>;
+};
+/**
+ * Declares which other components a component depends on within a system.
+ * Dependencies are expressed as an array of component keys. During build,
+ * the resolved outputs of these components are passed as the component's context.
+ *
+ * @typeParam Components - The full set of components in the system.
+ */
+type Dependency<Components extends Record<string, Lifecycle>> = (keyof Components)[];
+/**
+ * A {@link Lifecycle} produced by {@link compose}, extended with methods
+ * for controlling how components are routed to scopes during build.
+ *
+ * Because `ComposedSystem` extends `Lifecycle`, a composed system can be
+ * nested as a component inside another `compose` call — composition is
+ * recursive.
+ */
+export interface ComposedSystem<Components extends Record<string, Lifecycle>> extends Lifecycle<BuildResult<Components>> {
+    /**
+     * Returns a new {@link Lifecycle} that routes components to specific scopes
+     * (typically Stacks) during build. Components not listed in the map use the
+     * default scope passed to `build`.
+     *
+     * Accepts any `IConstruct`, so `Stack`, `DeploymentStack`, or custom
+     * subclasses all work.
+     *
+     * @param stacks - A partial map from component key to scope.
+     * @returns A {@link Lifecycle} with stack routing applied.
+     *
+     * @example
+     * ```ts
+     * compose({ handler, api }, { handler: [], api: ["handler"] })
+     *   .withStacks({ handler: serviceStack, api: apiStack })
+     *   .build(app, "MySystem");
+     * ```
+     */
+    withStacks(stacks: {
+        [K in keyof Components]?: IConstruct;
+    }): Lifecycle<BuildResult<Components>>;
+    /**
+     * Returns a new {@link Lifecycle} that uses a {@link StackStrategy} to
+     * determine each component's scope during build.
+     *
+     * @param strategy - The strategy that resolves scopes for components.
+     * @returns A {@link Lifecycle} with strategy-based stack routing applied.
+     *
+     * @example
+     * ```ts
+     * compose({ handler, api, table }, { ... })
+     *   .withStackStrategy(groupedStacks(
+     *     key => key === "table" ? "persistence" : "service",
+     *     (app, id) => new Stack(app, id),
+     *   ))
+     *   .build(app, "MySystem");
+     * ```
+     */
+    withStackStrategy(strategy: StackStrategy): Lifecycle<BuildResult<Components>>;
+}
+/**
+ * Composes a set of {@link Lifecycle} components into a single system that
+ * manages their build order and dependency resolution.
+ *
+ * A directed acyclic graph is built eagerly from the declared dependencies.
+ * Cyclic dependencies are detected at composition time and throw immediately.
+ * When `build` is called, components are built in topological order, each
+ * receiving the build outputs of its dependencies as its context.
+ *
+ * The returned {@link ComposedSystem} is a {@link Lifecycle}, so it can be
+ * nested as a component in a larger `compose` call.
+ *
+ * @param components - A record of named {@link Lifecycle} components.
+ * @param dependencies - For each component, the list of other component keys it depends on.
+ * @returns A {@link ComposedSystem} whose build output is the combined {@link BuildResult} of all components.
+ */
+export declare function compose<Components extends Record<string, Lifecycle>>(components: Components, dependencies: {
+    [Property in keyof Components]: Dependency<Components>;
+}): ComposedSystem<Components>;
+export {};
+//# sourceMappingURL=compose.d.ts.map

package/dist/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;;;;;GAMG;AACH,KAAK,WAAW,CAAC,CAAC,SAAS;KAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,SAAS;CAAE,IAAI;KAChE,QAAQ,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC;CACxD,CAAC;AAEF;;;;;;GAMG;AACH,KAAK,UAAU,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,UAAU,CAAC,EAAE,CAAC;AA+BrF;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAE,SAAQ,SAAS,CAC7F,WAAW,CAAC,UAAU,CAAC,CACxB;IACC;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,MAAM,EAAE;SAAG,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,UAAU;KAAE,GAAG,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjG;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;CAChF;AAyDD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAClE,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE;KAAG,QAAQ,IAAI,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;CAAE,GACvE,cAAc,CAAC,UAAU,CAAC,CAE5B"}

package/dist/compose.js

@@ -0,0 +1,81 @@
+import { alg, json } from "@dagrejs/graphlib";
+import { CyclicDependencyError } from "./cyclic-dependency-error.js";
+/**
+ * Builds a directed acyclic graph from component dependency declarations.
+ * The graph is described declaratively as nodes and edges, then constructed
+ * via {@link json.read}. Nodes are component keys, edges point from a
+ * dependency to its dependent. Throws if the graph contains a cycle.
+ */
+function buildDependencyGraph(components, dependencies) {
+    const nodes = Object.keys(components).map((v) => ({ v }));
+    const edges = Object.entries(dependencies).flatMap(([key, deps]) => deps.map((dep) => ({ v: dep, w: key })));
+    const graph = json.read({
+        options: { directed: true },
+        nodes,
+        edges,
+    });
+    if (!alg.isAcyclic(graph)) {
+        throw new CyclicDependencyError(alg.findCycles(graph));
+    }
+    return graph;
+}
+/**
+ * A composed system of {@link Lifecycle} components. Holds the dependency graph
+ * built at composition time and traverses it in topological order during build.
+ */
+class ComposedLifecycle {
+    components;
+    dependencies;
+    graph;
+    constructor(components, dependencies) {
+        this.components = components;
+        this.dependencies = dependencies;
+        this.graph = buildDependencyGraph(components, dependencies);
+    }
+    withStacks(stacks) {
+        return {
+            build: (scope, id) => this.buildWith(scope, id, stacks),
+        };
+    }
+    withStackStrategy(strategy) {
+        return {
+            build: (scope, id) => {
+                const stacks = Object.fromEntries(Object.keys(this.components).map((key) => [key, strategy.resolve(scope, id, key)]));
+                return this.buildWith(scope, id, stacks);
+            },
+        };
+    }
+    build(scope, id) {
+        return this.buildWith(scope, id);
+    }
+    buildWith(scope, id, stacks) {
+        const results = {};
+        for (const key of alg.topsort(this.graph)) {
+            const componentScope = stacks?.[key] ?? scope;
+            const deps = (this.dependencies[key] ?? []);
+            const context = Object.fromEntries(deps.map((dep) => [dep, results[dep]]));
+            results[key] = this.components[key].build(componentScope, `${id}/${key}`, context);
+        }
+        return results;
+    }
+}
+/**
+ * Composes a set of {@link Lifecycle} components into a single system that
+ * manages their build order and dependency resolution.
+ *
+ * A directed acyclic graph is built eagerly from the declared dependencies.
+ * Cyclic dependencies are detected at composition time and throw immediately.
+ * When `build` is called, components are built in topological order, each
+ * receiving the build outputs of its dependencies as its context.
+ *
+ * The returned {@link ComposedSystem} is a {@link Lifecycle}, so it can be
+ * nested as a component in a larger `compose` call.
+ *
+ * @param components - A record of named {@link Lifecycle} components.
+ * @param dependencies - For each component, the list of other component keys it depends on.
+ * @returns A {@link ComposedSystem} whose build output is the combined {@link BuildResult} of all components.
+ */
+export function compose(components, dependencies) {
+    return new ComposedLifecycle(components, dependencies);
+}
+//# sourceMappingURL=compose.js.map

package/dist/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"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"}

package/dist/cyclic-dependency-error.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Thrown when {@link compose} detects a cycle in the component dependency graph.
+ * Carries the detected cycles so callers can inspect or report them programmatically.
+ */
+export declare class CyclicDependencyError extends Error {
+    readonly cycles: string[][];
+    /**
+     * @param cycles - Each element is an array of component keys forming a cycle.
+     */
+    constructor(cycles: string[][]);
+}
+//# sourceMappingURL=cyclic-dependency-error.d.ts.map

package/dist/cyclic-dependency-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclic-dependency-error.d.ts","sourceRoot":"","sources":["../src/cyclic-dependency-error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAIlB,MAAM,EAAE,MAAM,EAAE,EAAE;IAH9C;;OAEG;gBACyB,MAAM,EAAE,MAAM,EAAE,EAAE;CAI/C"}

package/dist/cyclic-dependency-error.js

@@ -0,0 +1,16 @@
+/**
+ * Thrown when {@link compose} detects a cycle in the component dependency graph.
+ * Carries the detected cycles so callers can inspect or report them programmatically.
+ */
+export class CyclicDependencyError extends Error {
+    cycles;
+    /**
+     * @param cycles - Each element is an array of component keys forming a cycle.
+     */
+    constructor(cycles) {
+        super(`Cyclic dependencies detected: ${cycles.map((c) => c.join(" -> ")).join("; ")}`);
+        this.cycles = cycles;
+        this.name = "CyclicDependencyError";
+    }
+}
+//# sourceMappingURL=cyclic-dependency-error.js.map

package/dist/cyclic-dependency-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclic-dependency-error.js","sourceRoot":"","sources":["../src/cyclic-dependency-error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAIlB;IAH5B;;OAEG;IACH,YAA4B,MAAkB;QAC5C,KAAK,CAAC,iCAAiC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAD7D,WAAM,GAAN,MAAM,CAAY;QAE5C,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Builder, type IBuilder } from "./builder.js";
+export { compose, type ComposedSystem } from "./compose.js";
+export { CyclicDependencyError } from "./cyclic-dependency-error.js";
+export { type Lifecycle } from "./lifecycle.js";
+export { Ref, ref, resolve, isRef, type Resolvable } from "./ref.js";
+export { type StackStrategy, type ScopeFactory, singleStack, groupedStacks, } from "./stack-strategy.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,WAAW,EACX,aAAa,GACd,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { Builder } from "./builder.js";
+export { compose } from "./compose.js";
+export { CyclicDependencyError } from "./cyclic-dependency-error.js";
+export { Ref, ref, resolve, isRef } from "./ref.js";
+export { singleStack, groupedStacks, } from "./stack-strategy.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAiB,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,OAAO,EAAuB,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAmB,MAAM,UAAU,CAAC;AACrE,OAAO,EAGL,WAAW,EACX,aAAa,GACd,MAAM,qBAAqB,CAAC"}

package/dist/lifecycle.d.ts

@@ -0,0 +1,23 @@
+import { type IConstruct } from "constructs";
+/**
+ * Base type for the dependency context passed to a component's {@link Lifecycle.build} method.
+ * A record of named dependencies, each being a record of their build outputs.
+ */
+type LifecycleComponentBase = Record<string, object>;
+/**
+ * The core interface for all ComposureCDK components. A `Lifecycle` represents
+ * a unit of infrastructure that can be built within a CDK construct tree.
+ *
+ * Components implement this interface to define what resources they create
+ * and what dependencies they require. The {@link compose} function assembles
+ * components into a system, resolving dependencies and invoking `build` in
+ * the correct order.
+ *
+ * @typeParam T - The record of resources and values this component produces when built.
+ * @typeParam Context - The resolved dependencies this component requires, keyed by component name.
+ */
+export interface Lifecycle<T extends object = object, Context extends LifecycleComponentBase = LifecycleComponentBase> {
+    build(scope: IConstruct, id: string, context?: Context): T;
+}
+export {};
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;GAGG;AACH,KAAK,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS,CACxB,CAAC,SAAS,MAAM,GAAG,MAAM,EACzB,OAAO,SAAS,sBAAsB,GAAG,sBAAsB;IAE/D,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;CAC5D"}

package/dist/lifecycle.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lifecycle.js.map

package/dist/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":""}

package/dist/ref.d.ts

@@ -0,0 +1,114 @@
+/**
+ * A lazy reference to a value produced by another component at build time.
+ *
+ * `Ref` enables declarative cross-component wiring: a builder can capture a
+ * reference to a dependency's output at configuration time, and the value is
+ * resolved when the system is built. This keeps all configuration in one
+ * place — no split between eager props and deferred hooks.
+ *
+ * Create a `Ref` with the {@link ref} factory, then optionally narrow it
+ * with {@link Ref.get | .get()} or transform it with {@link Ref.map | .map()}.
+ *
+ * @typeParam T - The type of the value this reference resolves to.
+ *
+ * @example
+ * ```ts
+ * // Reference a component's full build output
+ * ref<FunctionBuilderResult>("handler")
+ *
+ * // Narrow to a specific property
+ * ref<FunctionBuilderResult>("handler").get("function")
+ *
+ * // Transform the referenced value
+ * ref<FunctionBuilderResult>("handler")
+ *   .get("function")
+ *   .map(fn => new LambdaIntegration(fn))
+ * ```
+ */
+export declare class Ref<T> {
+    private readonly _resolver;
+    private constructor();
+    /**
+     * Creates a `Ref` that resolves to a component's full build output.
+     *
+     * @param component - The key of the component in the composed system.
+     * @returns A `Ref` to the component's build result.
+     */
+    static to<T extends object>(component: string): Ref<T>;
+    /**
+     * Narrows this reference to a specific property of the resolved value.
+     *
+     * @param key - The property key to select.
+     * @returns A new `Ref` to the selected property.
+     */
+    get<K extends keyof T>(key: K): Ref<T[K]>;
+    /**
+     * Transforms the resolved value using the provided function.
+     *
+     * This is the primary way to adapt a dependency's output into the shape
+     * a consumer needs — for example, wrapping a Lambda function in a
+     * `LambdaIntegration`.
+     *
+     * @param fn - A function that transforms the resolved value.
+     * @returns A new `Ref` whose resolved value is the result of `fn`.
+     */
+    map<U>(fn: (value: T) => U): Ref<U>;
+    /**
+     * Resolves this reference against a build context.
+     *
+     * Called internally during the build phase. Not typically called by users.
+     *
+     * @param context - The resolved dependency outputs, keyed by component name.
+     * @returns The resolved value.
+     */
+    resolve(context: Record<string, object>): T;
+}
+/**
+ * Creates a {@link Ref} to a component's build output within a composed system.
+ *
+ * Called with just a component key, it returns a `Ref` to the full build result
+ * that can be further narrowed with {@link Ref.get | .get()} or
+ * {@link Ref.map | .map()}.
+ *
+ * Called with a transform function, it returns a `Ref` whose resolved value is
+ * the result of applying the transform to the component's build output. This is
+ * a shorthand for `ref<T>(component).map(transform)`.
+ *
+ * @param component - The key of the component in the composed system.
+ * @param transform - Optional function that transforms the component's build output.
+ * @returns A `Ref` to the component's build result, optionally transformed.
+ *
+ * @example
+ * ```ts
+ * // Without transform — chain .get() / .map() as needed
+ * ref<FunctionBuilderResult>("handler")
+ *   .get("function")
+ *   .map(fn => new LambdaIntegration(fn))
+ *
+ * // With transform — concise single-call form
+ * ref<FunctionBuilderResult>("handler", r => new LambdaIntegration(r.function))
+ * ```
+ */
+export declare function ref<T extends object>(component: string): Ref<T>;
+export declare function ref<T extends object, U>(component: string, transform: (value: T) => U): Ref<U>;
+/**
+ * A value that is either concrete or a lazy {@link Ref} resolved at build time.
+ *
+ * Builders accept `Resolvable<T>` wherever they would normally accept `T`,
+ * making refs and concrete values interchangeable at the call site.
+ */
+export type Resolvable<T> = T | Ref<T>;
+/**
+ * Type guard that checks whether a value is a {@link Ref}.
+ */
+export declare function isRef<T>(value: Resolvable<T>): value is Ref<T>;
+/**
+ * Resolves a {@link Resolvable} value. If it is a {@link Ref}, resolves it
+ * against the provided context. Otherwise returns the value as-is.
+ *
+ * @param value - A concrete value or a `Ref`.
+ * @param context - The resolved dependency outputs, keyed by component name.
+ * @returns The concrete value.
+ */
+export declare function resolve<T>(value: Resolvable<T>, context: Record<string, object>): T;
+//# sourceMappingURL=ref.d.ts.map

package/dist/ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../src/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,GAAG,CAAC,CAAC;IACI,OAAO,CAAC,QAAQ,CAAC,SAAS;IAA9C,OAAO;IAEP;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC;IAYtD;;;;;OAKG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAIzC;;;;;;;;;OASG;IACH,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IAInC;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC;CAG5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAEjE,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAShG;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAEvC;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,CAAC,CAE9D;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAEnF"}

package/dist/ref.js

@@ -0,0 +1,103 @@
+/**
+ * A lazy reference to a value produced by another component at build time.
+ *
+ * `Ref` enables declarative cross-component wiring: a builder can capture a
+ * reference to a dependency's output at configuration time, and the value is
+ * resolved when the system is built. This keeps all configuration in one
+ * place — no split between eager props and deferred hooks.
+ *
+ * Create a `Ref` with the {@link ref} factory, then optionally narrow it
+ * with {@link Ref.get | .get()} or transform it with {@link Ref.map | .map()}.
+ *
+ * @typeParam T - The type of the value this reference resolves to.
+ *
+ * @example
+ * ```ts
+ * // Reference a component's full build output
+ * ref<FunctionBuilderResult>("handler")
+ *
+ * // Narrow to a specific property
+ * ref<FunctionBuilderResult>("handler").get("function")
+ *
+ * // Transform the referenced value
+ * ref<FunctionBuilderResult>("handler")
+ *   .get("function")
+ *   .map(fn => new LambdaIntegration(fn))
+ * ```
+ */
+export class Ref {
+    _resolver;
+    constructor(_resolver) {
+        this._resolver = _resolver;
+    }
+    /**
+     * Creates a `Ref` that resolves to a component's full build output.
+     *
+     * @param component - The key of the component in the composed system.
+     * @returns A `Ref` to the component's build result.
+     */
+    static to(component) {
+        return new Ref((context) => {
+            if (!(component in context)) {
+                throw new Error(`Ref to "${component}" cannot be resolved: component not found in context. ` +
+                    `Ensure "${component}" is declared as a dependency.`);
+            }
+            return context[component];
+        });
+    }
+    /**
+     * Narrows this reference to a specific property of the resolved value.
+     *
+     * @param key - The property key to select.
+     * @returns A new `Ref` to the selected property.
+     */
+    get(key) {
+        return new Ref((context) => this._resolver(context)[key]);
+    }
+    /**
+     * Transforms the resolved value using the provided function.
+     *
+     * This is the primary way to adapt a dependency's output into the shape
+     * a consumer needs — for example, wrapping a Lambda function in a
+     * `LambdaIntegration`.
+     *
+     * @param fn - A function that transforms the resolved value.
+     * @returns A new `Ref` whose resolved value is the result of `fn`.
+     */
+    map(fn) {
+        return new Ref((context) => fn(this._resolver(context)));
+    }
+    /**
+     * Resolves this reference against a build context.
+     *
+     * Called internally during the build phase. Not typically called by users.
+     *
+     * @param context - The resolved dependency outputs, keyed by component name.
+     * @returns The resolved value.
+     */
+    resolve(context) {
+        return this._resolver(context);
+    }
+}
+export function ref(component, transform) {
+    const base = Ref.to(component);
+    return transform ? base.map(transform) : base;
+}
+/**
+ * Type guard that checks whether a value is a {@link Ref}.
+ */
+export function isRef(value) {
+    return value instanceof Ref;
+}
+/**
+ * Resolves a {@link Resolvable} value. If it is a {@link Ref}, resolves it
+ * against the provided context. Otherwise returns the value as-is.
+ *
+ * @param value - A concrete value or a `Ref`.
+ * @param context - The resolved dependency outputs, keyed by component name.
+ * @returns The concrete value.
+ */
+export function resolve(value, context) {
+    return isRef(value) ? value.resolve(context) : value;
+}
+//# sourceMappingURL=ref.js.map

package/dist/ref.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ref.js","sourceRoot":"","sources":["../src/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,OAAO,GAAG;IACuB;IAArC,YAAqC,SAAiD;QAAjD,cAAS,GAAT,SAAS,CAAwC;IAAG,CAAC;IAE1F;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAmB,SAAiB;QAC3C,OAAO,IAAI,GAAG,CAAI,CAAC,OAAO,EAAE,EAAE;YAC5B,IAAI,CAAC,CAAC,SAAS,IAAI,OAAO,CAAC,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,wDAAwD;oBAC1E,WAAW,SAAS,gCAAgC,CACvD,CAAC;YACJ,CAAC;YACD,OAAO,OAAO,CAAC,SAAS,CAAM,CAAC;QACjC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAoB,GAAM;QAC3B,OAAO,IAAI,GAAG,CAAO,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAI,EAAmB;QACxB,OAAO,IAAI,GAAG,CAAI,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,OAA+B;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;CACF;AA+BD,MAAM,UAAU,GAAG,CACjB,SAAiB,EACjB,SAA2B;IAE3B,MAAM,IAAI,GAAG,GAAG,CAAC,EAAE,CAAI,SAAS,CAAC,CAAC;IAClC,OAAO,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAChD,CAAC;AAUD;;GAEG;AACH,MAAM,UAAU,KAAK,CAAI,KAAoB;IAC3C,OAAO,KAAK,YAAY,GAAG,CAAC;AAC9B,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAI,KAAoB,EAAE,OAA+B;IAC9E,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACvD,CAAC"}

package/dist/stack-strategy.d.ts

@@ -0,0 +1,75 @@
+import { type IConstruct } from "constructs";
+/**
+ * A factory function that creates scopes (typically Stacks) for components.
+ * Accepts any scope constructor — `Stack`, `DeploymentStack`, or custom
+ * subclasses.
+ *
+ * @param scope - The parent scope (typically an `App`).
+ * @param id - A unique identifier for the new scope.
+ * @returns A new scope to attach components to.
+ */
+export type ScopeFactory = (scope: IConstruct, id: string) => IConstruct;
+/**
+ * Determines which scope a component should be built in.
+ *
+ * A `StackStrategy` is passed the parent scope, a system identifier,
+ * and each component's key. It returns the scope that component should
+ * use. Strategies can create scopes lazily, reuse them across components,
+ * or delegate to a {@link ScopeFactory} for custom scope types.
+ *
+ * @example
+ * ```ts
+ * // Every component in one auto-created stack
+ * compose({ handler, api }, { handler: [], api: ["handler"] })
+ *   .withStackStrategy(singleStack(myFactory))
+ *   .build(app, "MySystem");
+ *
+ * // Components grouped by a key function
+ * compose({ handler, api, table }, { ... })
+ *   .withStackStrategy(groupedStacks(key => key === "table" ? "persistence" : "service", myFactory))
+ *   .build(app, "MySystem");
+ * ```
+ */
+export interface StackStrategy {
+    /**
+     * Returns the scope a component should be built in.
+     *
+     * @param scope - The parent scope passed to `build`.
+     * @param systemId - The system identifier passed to `build`.
+     * @param componentKey - The key of the component in the composed system.
+     * @returns The scope to use for this component.
+     */
+    resolve(scope: IConstruct, systemId: string, componentKey: string): IConstruct;
+}
+/**
+ * Creates a strategy that places all components in a single auto-created scope.
+ *
+ * The scope is created lazily on the first call to `resolve` and reused for
+ * all subsequent components.
+ *
+ * @param factory - Factory for creating the scope (e.g. a Stack).
+ * @returns A {@link StackStrategy} that groups all components into one scope.
+ */
+export declare function singleStack(factory: ScopeFactory): StackStrategy;
+/**
+ * Creates a strategy that groups components into named scopes determined by
+ * a classifier function.
+ *
+ * Components that return the same group key share a scope. Scopes are created
+ * lazily as new group keys are encountered.
+ *
+ * @param classify - A function that maps a component key to a group name.
+ * @param factory - Factory for creating scopes (e.g. Stacks). The factory
+ *   receives `${systemId}-${group}` as the id.
+ * @returns A {@link StackStrategy} that groups components by classifier output.
+ *
+ * @example
+ * ```ts
+ * groupedStacks(
+ *   key => key === "table" ? "persistence" : "service",
+ *   (app, id) => new Stack(app, id),
+ * )
+ * ```
+ */
+export declare function groupedStacks(classify: (componentKey: string) => string, factory: ScopeFactory): StackStrategy;
+//# sourceMappingURL=stack-strategy.d.ts.map

package/dist/stack-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-strategy.d.ts","sourceRoot":"","sources":["../src/stack-strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,KAAK,UAAU,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,UAAU,CAAC;CAChF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa,CAUhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,EAC1C,OAAO,EAAE,YAAY,GACpB,aAAa,CAaf"}

package/dist/stack-strategy.js

@@ -0,0 +1,55 @@
+/**
+ * Creates a strategy that places all components in a single auto-created scope.
+ *
+ * The scope is created lazily on the first call to `resolve` and reused for
+ * all subsequent components.
+ *
+ * @param factory - Factory for creating the scope (e.g. a Stack).
+ * @returns A {@link StackStrategy} that groups all components into one scope.
+ */
+export function singleStack(factory) {
+    return {
+        resolve: (() => {
+            let stack;
+            return (scope, systemId) => {
+                stack ??= factory(scope, systemId);
+                return stack;
+            };
+        })(),
+    };
+}
+/**
+ * Creates a strategy that groups components into named scopes determined by
+ * a classifier function.
+ *
+ * Components that return the same group key share a scope. Scopes are created
+ * lazily as new group keys are encountered.
+ *
+ * @param classify - A function that maps a component key to a group name.
+ * @param factory - Factory for creating scopes (e.g. Stacks). The factory
+ *   receives `${systemId}-${group}` as the id.
+ * @returns A {@link StackStrategy} that groups components by classifier output.
+ *
+ * @example
+ * ```ts
+ * groupedStacks(
+ *   key => key === "table" ? "persistence" : "service",
+ *   (app, id) => new Stack(app, id),
+ * )
+ * ```
+ */
+export function groupedStacks(classify, factory) {
+    const groups = new Map();
+    return {
+        resolve(scope, systemId, componentKey) {
+            const group = classify(componentKey);
+            let groupScope = groups.get(group);
+            if (!groupScope) {
+                groupScope = factory(scope, `${systemId}-${group}`);
+                groups.set(group, groupScope);
+            }
+            return groupScope;
+        },
+    };
+}
+//# sourceMappingURL=stack-strategy.js.map

package/dist/stack-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack-strategy.js","sourceRoot":"","sources":["../src/stack-strategy.ts"],"names":[],"mappings":"AA8CA;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,OAAqB;IAC/C,OAAO;QACL,OAAO,EAAE,CAAC,GAAG,EAAE;YACb,IAAI,KAA6B,CAAC;YAClC,OAAO,CAAC,KAAiB,EAAE,QAAgB,EAAE,EAAE;gBAC7C,KAAK,KAAK,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;gBACnC,OAAO,KAAK,CAAC;YACf,CAAC,CAAC;QACJ,CAAC,CAAC,EAAE;KACL,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,aAAa,CAC3B,QAA0C,EAC1C,OAAqB;IAErB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC7C,OAAO;QACL,OAAO,CAAC,KAAiB,EAAE,QAAgB,EAAE,YAAoB;YAC/D,MAAM,KAAK,GAAG,QAAQ,CAAC,YAAY,CAAC,CAAC;YACrC,IAAI,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACnC,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,UAAU,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,QAAQ,IAAI,KAAK,EAAE,CAAC,CAAC;gBACpD,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;YAChC,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@composurecdk/core",
+  "version": "0.1.0",
+  "description": "Composable CDK component system — lifecycle, dependency resolution, and builder pattern",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
+  "keywords": [],
+  "author": "Jason Duffett (https://github.com/laazyj)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "peerDependencies": {
+    "constructs": "^10.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "dependencies": {
+    "@dagrejs/graphlib": "^4.0.1"
+  }
+}