@xplane/devtools 0.9.2 → 0.11.0

package/dist/assertions/index.d.mts

@@ -0,0 +1,178 @@
+import { Composition, KubernetesResource, KubernetesResource as KubernetesResource$1 } from "@xplane/core";
+
+//#region src/assertions/match.d.ts
+/** Symbol used to identify Matcher instances. */
+declare const MATCHER: unique symbol;
+/** Result of a match operation. */
+interface MatchResult {
+  /** Whether the match succeeded. */
+  pass: boolean;
+  /** Human-readable failure messages (empty if pass is true). */
+  failures: string[];
+}
+/** Interface for custom matchers. */
+interface Matcher {
+  readonly [MATCHER]: true;
+  test(actual: unknown): MatchResult;
+}
+/**
+ * Factory for composable matchers used in assertions.
+ *
+ * @example
+ * ```ts
+ * template.hasResourceSpec('v1', 'ConfigMap', {
+ *   data: Match.objectLike({ key: 'value' }),
+ * });
+ * ```
+ */
+declare class Match {
+  private constructor();
+  /** Deep-partial object match — actual may be a superset of pattern. */
+  static objectLike(pattern: object): Matcher;
+  /** Exact object match — actual must equal pattern exactly (same keys, same values). */
+  static objectEquals(pattern: object): Matcher;
+  /** Array subset match — items must appear in actual in order. */
+  static arrayWith(items: unknown[]): Matcher;
+  /** Exact array match — actual must equal items exactly. */
+  static arrayEquals(items: unknown[]): Matcher;
+  /** String regex match. */
+  static stringLikeRegexp(pattern: string | RegExp): Matcher;
+  /** Asserts the value is absent (undefined). */
+  static absent(): Matcher;
+  /** Asserts any non-null/non-undefined value is present. */
+  static anyValue(): Matcher;
+  /** Inverts a match — asserts the value does NOT match the given pattern. */
+  static not(pattern: unknown): Matcher;
+}
+//#endregion
+//#region src/assertions/template.d.ts
+/** Options for `Template.synthesize()`. */
+interface SynthesizeOptions {
+  /** XR (composite resource) data to inject before instantiation. */
+  xr?: Record<string, unknown>;
+  /** Environment data to inject before instantiation. */
+  environment?: Record<string, unknown>;
+}
+/**
+ * A snapshot of rendered resources from a Composition, providing
+ * assertion methods for unit testing.
+ *
+ * @example
+ * ```ts
+ * const template = Template.synthesize(MyComposition, {
+ *   xr: { spec: { region: 'us-east-1' } },
+ * });
+ * template.hasResourceSpec('ec2.aws.crossplane.io/v1beta1', 'VPC', {
+ *   forProvider: { region: 'us-east-1' },
+ * });
+ * ```
+ */
+declare class Template {
+  private readonly _resources;
+  private constructor();
+  /**
+   * Ergonomic factory: injects XR/environment data and instantiates
+   * the Composition class, then builds a Template from the rendered resources.
+   *
+   * Users never need to touch `Composition._pendingXR` directly.
+   */
+  static synthesize(Ctor: new () => Composition, options?: SynthesizeOptions): Template;
+  /**
+   * Build a Template from an already-instantiated Composition.
+   */
+  static fromComposition(composition: Composition): Template;
+  /**
+   * Build a Template from a pre-built array of KubernetesResource objects.
+   * Used internally by Simulator.
+   */
+  static fromResources(resources: KubernetesResource$1[]): Template;
+  /** Get all resources matching apiVersion + kind. */
+  private _filterByGVK;
+  /**
+   * Assert the number of resources with the given apiVersion and kind.
+   */
+  resourceCountIs(apiVersion: string, kind: string, count: number): void;
+  /**
+   * Assert that at least one resource of the given type matches the expected properties.
+   * Uses deep-partial matching by default (actual can be a superset of expected).
+   */
+  hasResource(apiVersion: string, kind: string, props?: object): void;
+  /**
+   * Assert that at least one resource of the given type has a spec matching the expected properties.
+   * Shorthand for matching against the `spec` field only.
+   */
+  hasResourceSpec(apiVersion: string, kind: string, specProps: object): void;
+  /**
+   * Assert that at least one resource of the given type has metadata matching the expected properties.
+   */
+  hasResourceMetadata(apiVersion: string, kind: string, metaProps: object): void;
+  /**
+   * Assert that ALL resources of the given type match the expected properties.
+   */
+  allResources(apiVersion: string, kind: string, props: object): void;
+  /**
+   * Find all resources of the given type that match the expected properties.
+   * Returns matches — never throws.
+   */
+  findResources(apiVersion: string, kind: string, props?: object): KubernetesResource$1[];
+  /**
+   * Serialize all resources to a JSON-compatible array for snapshot testing.
+   *
+   * @example
+   * ```ts
+   * expect(template.toJSON()).toMatchSnapshot();
+   * ```
+   */
+  toJSON(): KubernetesResource$1[];
+}
+//#endregion
+//#region src/assertions/simulator.d.ts
+/** Result of a simulation run. */
+interface SimulationResult {
+  /** Resources that are ready to emit (all dependencies satisfied). */
+  emitted: Template;
+  /** Resources that are blocked on unresolved dependencies. */
+  blocked: Template;
+}
+/**
+ * Simulates the full rendering pipeline including observed state injection,
+ * edge resolution, and sequencing — mimicking what `@xplane/function` does at runtime.
+ *
+ * @example
+ * ```ts
+ * const result = Simulator.synthesize(MyComposition, { xr: { ... } })
+ *   .withObserved([{ apiVersion: '...', kind: 'VPC', metadata: { name: 'vpc-abc' }, status: { atProvider: { vpcId: 'vpc-123' } } }])
+ *   .run();
+ *
+ * result.emitted.hasResourceSpec('ec2.aws.crossplane.io/v1beta1', 'Subnet', {
+ *   forProvider: { vpcId: 'vpc-123' },
+ * });
+ * ```
+ */
+declare class Simulator {
+  private readonly _composition;
+  private _observed;
+  private constructor();
+  /**
+   * Ergonomic factory: injects XR/environment data, instantiates the
+   * Composition class, and returns a Simulator ready for `.withObserved().run()`.
+   */
+  static synthesize(Ctor: new () => Composition, options?: SynthesizeOptions): Simulator;
+  /**
+   * Build a Simulator from an already-instantiated Composition.
+   */
+  static fromComposition(composition: Composition): Simulator;
+  /**
+   * Provide observed (cluster) state for resources.
+   * Each resource is matched to a declared resource by its construct path
+   * (i.e., `metadata.name` in observed state maps to `resource.path` in the composition).
+   */
+  withObserved(resources: KubernetesResource$1[]): this;
+  /**
+   * Run the simulation: inject observed state, resolve edges, determine sequencing.
+   */
+  run(): SimulationResult;
+}
+//#endregion
+export { type KubernetesResource, Match, type MatchResult, type Matcher, type SimulationResult, Simulator, type SynthesizeOptions, Template };
+//# sourceMappingURL=index.d.mts.map

package/dist/assertions/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/assertions/match.ts","../../src/assertions/template.ts","../../src/assertions/simulator.ts"],"mappings":";;;;cACa,OAAA;;UAGI,WAAA;EAH2C;EAK1D,IAAA;EAL0D;EAO1D,QAAQ;AAAA;;UAIO,OAAA;EAAA,UACL,OAAA;EACV,IAAA,CAAK,MAAA,YAAkB,WAAW;AAAA;;;;;;;;;;;cAwQvB,KAAA;EAAA,QACJ,WAAA,CAAA;EAG6B;EAAA,OAA7B,UAAA,CAAW,OAAA,WAAkB,OAAA;EAKhB;EAAA,OAAb,YAAA,CAAa,OAAA,WAAkB,OAAA;EAK/B;EAAA,OAAA,SAAA,CAAU,KAAA,cAAmB,OAAA;EAAA;EAAA,OAK7B,WAAA,CAAY,KAAA,cAAmB,OAAA;EAAnB;EAAA,OAKZ,gBAAA,CAAiB,OAAA,WAAkB,MAAA,GAAS,OAAA;EAA5C;EAAA,OAKA,MAAA,CAAA,GAAU,OAAA;EALO;EAAA,OAUjB,QAAA,CAAA,GAAY,OAAA;EALZ;EAAA,OAUA,GAAA,CAAI,OAAA,YAAmB,OAAA;AAAA;;;;UCzTf,iBAAA;EDHJ;ECKX,EAAA,GAAK,MAAA;;EAEL,WAAA,GAAc,MAAM;AAAA;ADJtB;;;;AAIU;AAIV;;;;;;;;;AARA,cCqBa,QAAA;EAAA,iBACM,UAAA;EAAA,QAEV,WAAA,CAAA;;;;;;;SAUA,UAAA,CAAW,IAAA,YAAgB,WAAA,EAAa,OAAA,GAAS,iBAAA,GAAyB,QAAA;ED6QhE;;;EAAA,OChPV,eAAA,CAAgB,WAAA,EAAa,WAAA,GAAc,QAAA;ED0Pb;;;;EAAA,OC3O9B,aAAA,CAAc,SAAA,EAAW,oBAAA,KAAuB,QAAA;ED6MhD;EAAA,QCxMC,YAAA;EDwM8B;;;ECjMtC,eAAA,CAAgB,UAAA,UAAoB,IAAA,UAAc,KAAA;ED2M3C;;;;EC9LP,WAAA,CAAY,UAAA,UAAoB,IAAA,UAAc,KAAA;EDmMtB;;;;EC1KxB,eAAA,CAAgB,UAAA,UAAoB,IAAA,UAAc,SAAA;EDoL/B;;;EC9JnB,mBAAA,CAAoB,UAAA,UAAoB,IAAA,UAAc,SAAA;EDmKjB;AAAA;;EC7IrC,YAAA,CAAa,UAAA,UAAoB,IAAA,UAAc,KAAA;;AA5KjD;;;EAsME,aAAA,CAAc,UAAA,UAAoB,IAAA,UAAc,KAAA,YAAiB,oBAAA;EApMjE;;;;;AAEoB;AAiBtB;;EAmME,MAAA,CAAA,GAAU,oBAAA;AAAA;;;;UClNK,gBAAA;EFT2C;EEW1D,OAAA,EAAS,QAAA;EFXiD;EEa1D,OAAA,EAAS,QAAQ;AAAA;;;;AFNT;AAIV;;;;;;;;;AAEoC;AAwQpC;cEzNa,SAAA;EAAA,iBACM,YAAA;EAAA,QACT,SAAA;EAAA,QAED,WAAA,CAAA;EFmO6B;;;;EAAA,OE3N7B,UAAA,CAAW,IAAA,YAAgB,WAAA,EAAa,OAAA,GAAS,iBAAA,GAAyB,SAAA;EF+O9D;;;EAAA,OElNZ,eAAA,CAAgB,WAAA,EAAa,WAAA,GAAc,SAAA;EFiL3C;;;;;EExKP,YAAA,CAAa,SAAA,EAAW,oBAAA;EFgLc;;;EExKtC,GAAA,CAAA,GAAO,gBAAA;AAAA"}

package/dist/assertions/index.mjs

@@ -0,0 +1,487 @@
+import { resolveSequencing } from "@xplane/core";
+//#region src/assertions/match.ts
+/** Symbol used to identify Matcher instances. */
+const MATCHER = Symbol.for("xplane.devtools.matcher");
+/** Check whether a value is a Matcher instance. */
+function isMatcher(value) {
+	return typeof value === "object" && value !== null && MATCHER in value && value[MATCHER] === true;
+}
+function pass() {
+	return {
+		pass: true,
+		failures: []
+	};
+}
+function fail(message) {
+	return {
+		pass: false,
+		failures: [message]
+	};
+}
+function merge(results) {
+	const failures = results.flatMap((r) => r.failures);
+	return {
+		pass: failures.length === 0,
+		failures
+	};
+}
+/**
+* Deep-match `actual` against `expected`.
+* - If `expected` is a Matcher, delegates to its `.test()`.
+* - Literal objects are matched recursively (deep-partial by default via objectLike semantics at the top level is handled by the caller).
+* - This function performs EXACT matching — partial matching is handled by ObjectLikeMatcher.
+*/
+function deepMatch(actual, expected, path = "") {
+	if (isMatcher(expected)) {
+		const result = expected.test(actual);
+		if (!result.pass) return {
+			pass: false,
+			failures: result.failures.map((f) => path ? `${path}: ${f}` : f)
+		};
+		return pass();
+	}
+	if (expected === null || expected === void 0 || typeof expected !== "object") {
+		if (actual === expected) return pass();
+		return fail(path ? `${path}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}` : `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+	}
+	if (Array.isArray(expected)) {
+		if (!Array.isArray(actual)) return fail(`${path || "value"}: expected an array, got ${typeof actual}`);
+		if (actual.length !== expected.length) return fail(`${path || "value"}: expected array of length ${expected.length}, got length ${actual.length}`);
+		const results = [];
+		for (let i = 0; i < expected.length; i++) results.push(deepMatch(actual[i], expected[i], `${path}[${i}]`));
+		return merge(results);
+	}
+	if (typeof actual !== "object" || actual === null || Array.isArray(actual)) return fail(`${path || "value"}: expected an object, got ${JSON.stringify(actual)}`);
+	const expectedObj = expected;
+	const actualObj = actual;
+	const results = [];
+	for (const key of Object.keys(expectedObj)) results.push(deepMatch(actualObj[key], expectedObj[key], path ? `${path}.${key}` : key));
+	for (const key of Object.keys(actualObj)) if (!(key in expectedObj)) results.push(fail(`${path ? `${path}.${key}` : key}: unexpected key`));
+	return merge(results);
+}
+/**
+* Deep-partial match: all keys in `expected` must match in `actual`, but
+* `actual` may have additional keys at any level.
+*/
+function deepPartialMatch(actual, expected, path = "") {
+	if (isMatcher(expected)) {
+		const result = expected.test(actual);
+		if (!result.pass) return {
+			pass: false,
+			failures: result.failures.map((f) => path ? `${path}: ${f}` : f)
+		};
+		return pass();
+	}
+	if (expected === null || expected === void 0 || typeof expected !== "object") {
+		if (actual === expected) return pass();
+		return fail(path ? `${path}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}` : `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+	}
+	if (Array.isArray(expected)) {
+		if (!Array.isArray(actual)) return fail(`${path || "value"}: expected an array, got ${typeof actual}`);
+		if (actual.length !== expected.length) return fail(`${path || "value"}: expected array of length ${expected.length}, got length ${actual.length}`);
+		const results = [];
+		for (let i = 0; i < expected.length; i++) results.push(deepPartialMatch(actual[i], expected[i], `${path}[${i}]`));
+		return merge(results);
+	}
+	if (typeof actual !== "object" || actual === null || Array.isArray(actual)) return fail(`${path || "value"}: expected an object, got ${JSON.stringify(actual)}`);
+	const expectedObj = expected;
+	const actualObj = actual;
+	const results = [];
+	for (const key of Object.keys(expectedObj)) if (!(key in actualObj)) results.push(fail(`${path ? `${path}.${key}` : key}: key not found in actual`));
+	else results.push(deepPartialMatch(actualObj[key], expectedObj[key], path ? `${path}.${key}` : key));
+	return merge(results);
+}
+var ObjectLikeMatcher = class {
+	pattern;
+	[MATCHER] = true;
+	constructor(pattern) {
+		this.pattern = pattern;
+	}
+	test(actual) {
+		return deepPartialMatch(actual, this.pattern);
+	}
+};
+var ObjectEqualsMatcher = class {
+	pattern;
+	[MATCHER] = true;
+	constructor(pattern) {
+		this.pattern = pattern;
+	}
+	test(actual) {
+		return deepMatch(actual, this.pattern);
+	}
+};
+var ArrayWithMatcher = class {
+	items;
+	[MATCHER] = true;
+	constructor(items) {
+		this.items = items;
+	}
+	test(actual) {
+		if (!Array.isArray(actual)) return fail(`expected an array, got ${typeof actual}`);
+		let searchStart = 0;
+		for (let i = 0; i < this.items.length; i++) {
+			let found = false;
+			for (let j = searchStart; j < actual.length; j++) if (deepPartialMatch(actual[j], this.items[i]).pass) {
+				searchStart = j + 1;
+				found = true;
+				break;
+			}
+			if (!found) return fail(`arrayWith: could not find match for item at index ${i}: ${JSON.stringify(this.items[i])}`);
+		}
+		return pass();
+	}
+};
+var ArrayEqualsMatcher = class {
+	items;
+	[MATCHER] = true;
+	constructor(items) {
+		this.items = items;
+	}
+	test(actual) {
+		return deepMatch(actual, this.items);
+	}
+};
+var StringLikeRegexpMatcher = class {
+	[MATCHER] = true;
+	regex;
+	constructor(pattern) {
+		this.regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+	}
+	test(actual) {
+		if (typeof actual !== "string") return fail(`expected a string, got ${typeof actual}`);
+		if (!this.regex.test(actual)) return fail(`expected string matching ${this.regex}, got "${actual}"`);
+		return pass();
+	}
+};
+var AbsentMatcher = class {
+	[MATCHER] = true;
+	test(actual) {
+		if (actual !== void 0) return fail(`expected absent (undefined), got ${JSON.stringify(actual)}`);
+		return pass();
+	}
+};
+var AnyValueMatcher = class {
+	[MATCHER] = true;
+	test(actual) {
+		if (actual === null || actual === void 0) return fail(`expected any value, got ${actual}`);
+		return pass();
+	}
+};
+var NotMatcher = class {
+	pattern;
+	[MATCHER] = true;
+	constructor(pattern) {
+		this.pattern = pattern;
+	}
+	test(actual) {
+		if ((isMatcher(this.pattern) ? this.pattern.test(actual) : deepPartialMatch(actual, this.pattern)).pass) return fail(`expected NOT to match, but matched: ${JSON.stringify(actual)}`);
+		return pass();
+	}
+};
+/**
+* Factory for composable matchers used in assertions.
+*
+* @example
+* ```ts
+* template.hasResourceSpec('v1', 'ConfigMap', {
+*   data: Match.objectLike({ key: 'value' }),
+* });
+* ```
+*/
+var Match = class {
+	constructor() {}
+	/** Deep-partial object match — actual may be a superset of pattern. */
+	static objectLike(pattern) {
+		return new ObjectLikeMatcher(pattern);
+	}
+	/** Exact object match — actual must equal pattern exactly (same keys, same values). */
+	static objectEquals(pattern) {
+		return new ObjectEqualsMatcher(pattern);
+	}
+	/** Array subset match — items must appear in actual in order. */
+	static arrayWith(items) {
+		return new ArrayWithMatcher(items);
+	}
+	/** Exact array match — actual must equal items exactly. */
+	static arrayEquals(items) {
+		return new ArrayEqualsMatcher(items);
+	}
+	/** String regex match. */
+	static stringLikeRegexp(pattern) {
+		return new StringLikeRegexpMatcher(pattern);
+	}
+	/** Asserts the value is absent (undefined). */
+	static absent() {
+		return new AbsentMatcher();
+	}
+	/** Asserts any non-null/non-undefined value is present. */
+	static anyValue() {
+		return new AnyValueMatcher();
+	}
+	/** Inverts a match — asserts the value does NOT match the given pattern. */
+	static not(pattern) {
+		return new NotMatcher(pattern);
+	}
+};
+//#endregion
+//#region src/assertions/template.ts
+/**
+* A snapshot of rendered resources from a Composition, providing
+* assertion methods for unit testing.
+*
+* @example
+* ```ts
+* const template = Template.synthesize(MyComposition, {
+*   xr: { spec: { region: 'us-east-1' } },
+* });
+* template.hasResourceSpec('ec2.aws.crossplane.io/v1beta1', 'VPC', {
+*   forProvider: { region: 'us-east-1' },
+* });
+* ```
+*/
+var Template = class Template {
+	_resources;
+	constructor(resources) {
+		this._resources = resources;
+	}
+	/**
+	* Ergonomic factory: injects XR/environment data and instantiates
+	* the Composition class, then builds a Template from the rendered resources.
+	*
+	* Users never need to touch `Composition._pendingXR` directly.
+	*/
+	static synthesize(Ctor, options = {}) {
+		let base = Ctor;
+		while (base && !Object.hasOwn(base, "_pendingXR")) base = Object.getPrototypeOf(base);
+		if (!base) throw new Error("Could not find Composition base class with _pendingXR");
+		const BaseComposition = base;
+		BaseComposition._pendingXR = options.xr;
+		BaseComposition._pendingEnvironment = options.environment;
+		try {
+			const instance = new Ctor();
+			return Template.fromComposition(instance);
+		} finally {
+			BaseComposition._pendingXR = void 0;
+			BaseComposition._pendingEnvironment = void 0;
+		}
+	}
+	/**
+	* Build a Template from an already-instantiated Composition.
+	*/
+	static fromComposition(composition) {
+		return new Template([...composition.resources.values()].map((r) => r.toDesired()));
+	}
+	/**
+	* Build a Template from a pre-built array of KubernetesResource objects.
+	* Used internally by Simulator.
+	*/
+	static fromResources(resources) {
+		return new Template(resources);
+	}
+	/** Get all resources matching apiVersion + kind. */
+	_filterByGVK(apiVersion, kind) {
+		return this._resources.filter((r) => r.apiVersion === apiVersion && r.kind === kind);
+	}
+	/**
+	* Assert the number of resources with the given apiVersion and kind.
+	*/
+	resourceCountIs(apiVersion, kind, count) {
+		const matched = this._filterByGVK(apiVersion, kind);
+		if (matched.length !== count) throw new Error(`Expected ${count} resource(s) of type ${apiVersion}/${kind}, found ${matched.length}`);
+	}
+	/**
+	* Assert that at least one resource of the given type matches the expected properties.
+	* Uses deep-partial matching by default (actual can be a superset of expected).
+	*/
+	hasResource(apiVersion, kind, props) {
+		const matched = this._filterByGVK(apiVersion, kind);
+		if (matched.length === 0) throw new Error(`No resources found with type ${apiVersion}/${kind}`);
+		if (!props) return;
+		const allFailures = [];
+		for (const resource of matched) {
+			const result = deepPartialMatch(resource, props);
+			if (result.pass) return;
+			allFailures.push(`  Resource: ${JSON.stringify(resource.metadata?.name ?? "(unnamed)")}\n    ${result.failures.join("\n    ")}`);
+		}
+		throw new Error(`No resource of type ${apiVersion}/${kind} matches the expected properties:\n${allFailures.join("\n")}`);
+	}
+	/**
+	* Assert that at least one resource of the given type has a spec matching the expected properties.
+	* Shorthand for matching against the `spec` field only.
+	*/
+	hasResourceSpec(apiVersion, kind, specProps) {
+		const matched = this._filterByGVK(apiVersion, kind);
+		if (matched.length === 0) throw new Error(`No resources found with type ${apiVersion}/${kind}`);
+		const allFailures = [];
+		for (const resource of matched) {
+			const result = deepPartialMatch(resource.spec ?? {}, specProps);
+			if (result.pass) return;
+			allFailures.push(`  Resource: ${JSON.stringify(resource.metadata?.name ?? "(unnamed)")}\n    ${result.failures.join("\n    ")}`);
+		}
+		throw new Error(`No resource of type ${apiVersion}/${kind} has spec matching the expected properties:\n${allFailures.join("\n")}`);
+	}
+	/**
+	* Assert that at least one resource of the given type has metadata matching the expected properties.
+	*/
+	hasResourceMetadata(apiVersion, kind, metaProps) {
+		const matched = this._filterByGVK(apiVersion, kind);
+		if (matched.length === 0) throw new Error(`No resources found with type ${apiVersion}/${kind}`);
+		const allFailures = [];
+		for (const resource of matched) {
+			const result = deepPartialMatch(resource.metadata ?? {}, metaProps);
+			if (result.pass) return;
+			allFailures.push(`  Resource: ${JSON.stringify(resource.metadata?.name ?? "(unnamed)")}\n    ${result.failures.join("\n    ")}`);
+		}
+		throw new Error(`No resource of type ${apiVersion}/${kind} has metadata matching the expected properties:\n${allFailures.join("\n")}`);
+	}
+	/**
+	* Assert that ALL resources of the given type match the expected properties.
+	*/
+	allResources(apiVersion, kind, props) {
+		const matched = this._filterByGVK(apiVersion, kind);
+		if (matched.length === 0) throw new Error(`No resources found with type ${apiVersion}/${kind}`);
+		const failures = [];
+		for (const resource of matched) {
+			const result = deepPartialMatch(resource, props);
+			if (!result.pass) failures.push(`  Resource: ${JSON.stringify(resource.metadata?.name ?? "(unnamed)")}\n    ${result.failures.join("\n    ")}`);
+		}
+		if (failures.length > 0) throw new Error(`Not all resources of type ${apiVersion}/${kind} match:\n${failures.join("\n")}`);
+	}
+	/**
+	* Find all resources of the given type that match the expected properties.
+	* Returns matches — never throws.
+	*/
+	findResources(apiVersion, kind, props) {
+		const matched = this._filterByGVK(apiVersion, kind);
+		if (!props) return matched;
+		return matched.filter((resource) => {
+			return deepPartialMatch(resource, props).pass;
+		});
+	}
+	/**
+	* Serialize all resources to a JSON-compatible array for snapshot testing.
+	*
+	* @example
+	* ```ts
+	* expect(template.toJSON()).toMatchSnapshot();
+	* ```
+	*/
+	toJSON() {
+		return structuredClone(this._resources);
+	}
+};
+//#endregion
+//#region src/assertions/simulator.ts
+function getNestedValue(obj, path) {
+	let current = obj;
+	for (const segment of path.split(".")) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[segment];
+	}
+	return current;
+}
+function setNestedValue(obj, path, value) {
+	const segments = path.split(".");
+	let current = obj;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const seg = segments[i];
+		if (!(seg in current) || typeof current[seg] !== "object" || current[seg] === null) current[seg] = {};
+		current = current[seg];
+	}
+	const lastSeg = segments[segments.length - 1];
+	if (lastSeg !== void 0) current[lastSeg] = value;
+}
+/**
+* Simulates the full rendering pipeline including observed state injection,
+* edge resolution, and sequencing — mimicking what `@xplane/function` does at runtime.
+*
+* @example
+* ```ts
+* const result = Simulator.synthesize(MyComposition, { xr: { ... } })
+*   .withObserved([{ apiVersion: '...', kind: 'VPC', metadata: { name: 'vpc-abc' }, status: { atProvider: { vpcId: 'vpc-123' } } }])
+*   .run();
+*
+* result.emitted.hasResourceSpec('ec2.aws.crossplane.io/v1beta1', 'Subnet', {
+*   forProvider: { vpcId: 'vpc-123' },
+* });
+* ```
+*/
+var Simulator = class Simulator {
+	_composition;
+	_observed = [];
+	constructor(composition) {
+		this._composition = composition;
+	}
+	/**
+	* Ergonomic factory: injects XR/environment data, instantiates the
+	* Composition class, and returns a Simulator ready for `.withObserved().run()`.
+	*/
+	static synthesize(Ctor, options = {}) {
+		let base = Ctor;
+		while (base && !Object.hasOwn(base, "_pendingXR")) base = Object.getPrototypeOf(base);
+		if (!base) throw new Error("Could not find Composition base class with _pendingXR");
+		const BaseComposition = base;
+		BaseComposition._pendingXR = options.xr;
+		BaseComposition._pendingEnvironment = options.environment;
+		try {
+			return new Simulator(new Ctor());
+		} finally {
+			BaseComposition._pendingXR = void 0;
+			BaseComposition._pendingEnvironment = void 0;
+		}
+	}
+	/**
+	* Build a Simulator from an already-instantiated Composition.
+	*/
+	static fromComposition(composition) {
+		return new Simulator(composition);
+	}
+	/**
+	* Provide observed (cluster) state for resources.
+	* Each resource is matched to a declared resource by its construct path
+	* (i.e., `metadata.name` in observed state maps to `resource.path` in the composition).
+	*/
+	withObserved(resources) {
+		this._observed = resources;
+		return this;
+	}
+	/**
+	* Run the simulation: inject observed state, resolve edges, determine sequencing.
+	*/
+	run() {
+		const composition = this._composition;
+		const resources = composition.resources;
+		const collector = composition.collector;
+		const graph = composition.graph;
+		const observedMap = /* @__PURE__ */ new Map();
+		for (const obs of this._observed) {
+			const name = obs.metadata?.name;
+			if (name) observedMap.set(name, obs);
+		}
+		graph.addEdges(collector.edges);
+		for (const [path, resource] of resources) {
+			const observed = observedMap.get(path);
+			if (observed) resource.setObserved(observed);
+		}
+		for (const edge of collector.edges) {
+			const observed = observedMap.get(edge.from.id);
+			if (!observed) continue;
+			const value = getNestedValue(observed, edge.fromPath);
+			if (value === void 0 || value === null) continue;
+			const targetResource = resources.get(edge.to.id);
+			if (!targetResource) continue;
+			const toPath = edge.toPath;
+			if (toPath.startsWith("spec.")) setNestedValue(targetResource.spec, toPath.slice(5), value);
+		}
+		const sequencing = resolveSequencing(resources, graph, observedMap);
+		return {
+			emitted: Template.fromResources(sequencing.emit.map((r) => r.toDesired())),
+			blocked: Template.fromResources(sequencing.blocked.map((r) => r.toDesired()))
+		};
+	}
+};
+//#endregion
+export { Match, Simulator, Template };
+
+//# sourceMappingURL=index.mjs.map