@azure/provisioning-core 1.0.0-beta.1

package/dist/commonjs/constructs/resource/resource-proxy.js

@@ -0,0 +1,456 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resource_proxy_exports = {};
+__export(resource_proxy_exports, {
+  INDEXED_PROXY_TARGET: () => INDEXED_PROXY_TARGET,
+  LOOPED_RESOURCE_BRAND: () => LOOPED_RESOURCE_BRAND,
+  PROXY_INDEX_REF: () => PROXY_INDEX_REF,
+  RAW_RESOURCE_HANDLE: () => RAW_RESOURCE_HANDLE,
+  RESOURCE_BRAND: () => RESOURCE_BRAND,
+  RESOURCE_DECLARATION_BRAND: () => RESOURCE_DECLARATION_BRAND,
+  STATE_PARENT_INDEX: () => STATE_PARENT_INDEX,
+  createIndexedResourceProxy: () => createIndexedResourceProxy,
+  createResourceMemberProxy: () => createResourceMemberProxy,
+  createResourceProxy: () => createResourceProxy,
+  deref: () => deref,
+  normalizeAssignedValue: () => normalizeAssignedValue,
+  unwrapResourceHandle: () => unwrapResourceHandle
+});
+module.exports = __toCommonJS(resource_proxy_exports);
+var import_expressions = require("../../expression/expressions.js");
+var import_ast_nodes = require("../../expression/ast-nodes.js");
+var import_shape = require("../../shape/shape.js");
+var import_shape_registry = require("../../shape/shape-registry.js");
+const RAW_RESOURCE_HANDLE = /* @__PURE__ */ Symbol("raw-resource-handle");
+const RESOURCE_BRAND = /* @__PURE__ */ Symbol.for("@azure/provisioning-core.Resource");
+const LOOPED_RESOURCE_BRAND = /* @__PURE__ */ Symbol.for("@azure/provisioning-core.LoopedResource");
+const RESOURCE_DECLARATION_BRAND = /* @__PURE__ */ Symbol.for(
+  "@azure/provisioning-core.ResourceDeclaration"
+);
+const PROXY_INDEX_REF = /* @__PURE__ */ Symbol.for("@azure/provisioning-core.PROXY_INDEX_REF");
+const INDEXED_PROXY_TARGET = /* @__PURE__ */ Symbol.for("@azure/provisioning-core.INDEXED_PROXY_TARGET");
+const STATE_PARENT_INDEX = "parentIndex";
+function stepsToPath(steps) {
+  return steps.map((s) => s.segment);
+}
+const PROPERTY_PROXY_STATE = /* @__PURE__ */ Symbol("property-proxy-state");
+function isPropertyProxy(value) {
+  return typeof value === "object" && value !== null && Reflect.get(value, PROPERTY_PROXY_STATE) !== void 0;
+}
+function getPropertyProxyState(value) {
+  return value[PROPERTY_PROXY_STATE];
+}
+function deref(value) {
+  if (isPropertyProxy(value)) {
+    const state = getPropertyProxyState(value);
+    return getValueAtPath(state.root, stepsToPath(state.steps));
+  }
+  if (isResourceHandle(value)) {
+    return unwrapResourceHandle(value);
+  }
+  return value;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function getValueAtPath(root, path) {
+  let current = root;
+  for (const segment of path) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    if (!Object.prototype.hasOwnProperty.call(current, String(segment))) {
+      return void 0;
+    }
+    current = current[String(segment)];
+  }
+  return current;
+}
+function setValueAtPath(root, path, value) {
+  let current = root;
+  for (let index = 0; index < path.length - 1; index += 1) {
+    const segment = String(path[index]);
+    const nextSegment = path[index + 1];
+    const existing = Object.prototype.hasOwnProperty.call(current, segment) ? current[segment] : void 0;
+    if (typeof existing === "object" && existing !== null) {
+      current = existing;
+      continue;
+    }
+    const container = typeof nextSegment === "number" ? [] : /* @__PURE__ */ Object.create(null);
+    Object.defineProperty(current, segment, {
+      value: container,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+    current = container;
+  }
+  Object.defineProperty(current, String(path[path.length - 1]), {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function createMemberAccessPathExpression(resource, steps, index) {
+  let current = (0, import_ast_nodes.identifierExpressionNode)(resource);
+  if (index !== void 0) {
+    current = (0, import_ast_nodes.arrayAccessExpressionNode)(current, index);
+  }
+  for (const { segment, armPath } of steps) {
+    current = (0, import_ast_nodes.accessExpressionNode)(current, segment, { armPath });
+  }
+  return current;
+}
+function normalizeAssignedValue(value, currentResource) {
+  if (isPropertyProxy(value)) {
+    const state = getPropertyProxyState(value);
+    if (currentResource && state.resource === currentResource) {
+      return getValueAtPath(state.root, stepsToPath(state.steps));
+    }
+    return createMemberAccessPathExpression(state.resource, state.steps, state.index);
+  }
+  if (isResourceHandle(value)) {
+    return (0, import_ast_nodes.identifierExpressionNode)(value);
+  }
+  if ((0, import_expressions.isExpression)(value)) {
+    return (0, import_expressions.unwrapExpression)(value);
+  }
+  if ((0, import_ast_nodes.isExpressionNode)(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeAssignedValue(item, currentResource));
+  }
+  if (isPlainObject(value)) {
+    return normalizeObjectValue(value, currentResource);
+  }
+  return value;
+}
+function normalizeObjectValue(obj, currentResource) {
+  const entries = Object.entries(obj);
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of entries) {
+    if (isPropertyProxy(value)) {
+      const state = getPropertyProxyState(value);
+      if (currentResource && state.resource === currentResource) {
+        result[key] = getValueAtPath(state.root, stepsToPath(state.steps));
+        continue;
+      }
+    }
+    result[key] = normalizeAssignedValue(value, currentResource);
+  }
+  return result;
+}
+function toPropertySegment(property, nav, currentValue) {
+  const isIndexedContainer = nav?.kind === "array" || nav?.kind === "tuple" || Array.isArray(currentValue);
+  return isIndexedContainer && /^\d+$/u.test(property) ? Number(property) : property;
+}
+function getPropertyProxyTarget(state) {
+  const currentValue = getValueAtPath(state.root, stepsToPath(state.steps));
+  if (typeof currentValue === "object" && currentValue !== null) {
+    return currentValue;
+  }
+  return {};
+}
+function createPropertyProxy(state) {
+  const target = {};
+  return new Proxy(target, {
+    has(proxyTarget, property) {
+      if (property === PROPERTY_PROXY_STATE || property === import_expressions.EXPRESSION_BRAND) {
+        return true;
+      }
+      const backing = getPropertyProxyTarget(state);
+      if (Reflect.has(backing, property)) return true;
+      return Reflect.has(proxyTarget, property);
+    },
+    ownKeys() {
+      const backing = getPropertyProxyTarget(state);
+      return Reflect.ownKeys(backing).filter((k) => typeof k === "string");
+    },
+    getOwnPropertyDescriptor(_proxyTarget, property) {
+      const backing = getPropertyProxyTarget(state);
+      if (typeof property === "string" && Object.prototype.hasOwnProperty.call(backing, property)) {
+        return { enumerable: true, configurable: true, writable: true };
+      }
+      return void 0;
+    },
+    get(proxyTarget, property, receiver) {
+      if (property === PROPERTY_PROXY_STATE) {
+        return state;
+      }
+      if (property === import_expressions.EXPRESSION_BRAND) {
+        return createMemberAccessPathExpression(state.resource, state.steps, state.index);
+      }
+      if (property === Symbol.toPrimitive) {
+        return () => `[ResourceMember ${stepsToPath(state.steps).map(String).join(".")}]`;
+      }
+      if (typeof property !== "string") {
+        return Reflect.get(proxyTarget, property, receiver);
+      }
+      if (property === "toString") {
+        return () => `[ResourceMember ${stepsToPath(state.steps).map(String).join(".")}]`;
+      }
+      if (property === "valueOf") {
+        return () => createMemberAccessPathExpression(state.resource, state.steps, state.index);
+      }
+      if (property === "then") {
+        return void 0;
+      }
+      const currentValue = getValueAtPath(state.root, stepsToPath(state.steps));
+      const segment = toPropertySegment(property, state.nav, currentValue);
+      const step = (0, import_shape.navigateShape)(state.nav, segment, currentValue);
+      const nextArmPath = step.stamp?.armPath;
+      const nextNav = step.next;
+      return createPropertyProxy({
+        ...state,
+        steps: [...state.steps, { segment, armPath: nextArmPath }],
+        nav: nextNav
+      });
+    },
+    set(_proxyTarget, property, value) {
+      if (typeof property !== "string") {
+        return false;
+      }
+      if (state.index !== void 0) {
+        throwLoopedElementWriteError();
+      }
+      setValueAtPath(
+        state.root,
+        [
+          ...stepsToPath(state.steps),
+          toPropertySegment(
+            property,
+            state.nav,
+            getValueAtPath(state.root, stepsToPath(state.steps))
+          )
+        ],
+        normalizeAssignedValue(value, state.resource)
+      );
+      return true;
+    }
+  });
+}
+function isNonEnumerableOwnProperty(target, property) {
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+  return descriptor?.enumerable === false;
+}
+function hasOwnOrPrototypeProperty(target, property) {
+  let current = target;
+  while (current !== null) {
+    if (Object.prototype.hasOwnProperty.call(current, property)) {
+      return true;
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return false;
+}
+function createResourceMemberProxy(source, path) {
+  const rootShape = getResourceShape(source.resource);
+  let nav = rootShape;
+  const steps = [];
+  for (const segment of path) {
+    const step = (0, import_shape.navigateShape)(nav, segment, getValueAtPath(source.root, stepsToPath(steps)));
+    steps.push({ segment, armPath: step.stamp?.armPath });
+    nav = step.next;
+  }
+  return createPropertyProxy({
+    ...source,
+    steps,
+    nav
+  });
+}
+function getResourceShape(resource) {
+  const state = resource[RAW_RESOURCE_HANDLE];
+  return (0, import_shape_registry.getShape)(resource.type, resource.apiVersion, state);
+}
+function createResourceProxy(resource) {
+  function getBackingResourceData(target) {
+    return Reflect.get(target, RAW_RESOURCE_HANDLE);
+  }
+  const proxy = new Proxy(resource, {
+    ownKeys(target) {
+      return Array.from(
+        /* @__PURE__ */ new Set([
+          ...Reflect.ownKeys(target),
+          ...Reflect.ownKeys(getBackingResourceData(target)).filter(
+            (key) => key !== RAW_RESOURCE_HANDLE
+          )
+        ])
+      );
+    },
+    getOwnPropertyDescriptor(target, property) {
+      const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, property);
+      if (targetDescriptor !== void 0) {
+        return targetDescriptor;
+      }
+      const backing = getBackingResourceData(target);
+      if (Object.prototype.hasOwnProperty.call(backing, property)) {
+        return { enumerable: true, configurable: true, writable: true };
+      }
+      return void 0;
+    },
+    get(target, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property === "then") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (hasOwnOrPrototypeProperty(target, property) || isNonEnumerableOwnProperty(target, property)) {
+        return Reflect.get(target, property, receiver);
+      }
+      const rootState = unwrapResourceHandle(proxy);
+      const rootShape = getResourceShape(target);
+      const segment = toPropertySegment(property, rootShape, rootState);
+      const step = (0, import_shape.navigateShape)(rootShape, segment, rootState);
+      const armPath = step.stamp?.armPath;
+      const nav = step.next;
+      return createPropertyProxy({
+        resource: proxy,
+        root: rootState,
+        steps: [{ segment, armPath }],
+        nav
+      });
+    },
+    set(target, property, value, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.set(target, property, value, receiver);
+      }
+      if (hasOwnOrPrototypeProperty(target, property) || isNonEnumerableOwnProperty(target, property)) {
+        return Reflect.set(target, property, value, receiver);
+      }
+      setValueAtPath(
+        unwrapResourceHandle(proxy),
+        [toPropertySegment(property, getResourceShape(target), unwrapResourceHandle(proxy))],
+        normalizeAssignedValue(value, proxy)
+      );
+      return true;
+    }
+  });
+  return proxy;
+}
+function isResourceHandle(value) {
+  return typeof value === "object" && value !== null && value[RESOURCE_BRAND] === true;
+}
+function unwrapResourceHandle(resource) {
+  const maybeRaw = Reflect.get(resource, RAW_RESOURCE_HANDLE);
+  if (maybeRaw === void 0) {
+    return resource;
+  }
+  return maybeRaw;
+}
+function throwLoopedElementWriteError() {
+  throw new Error(
+    "Cannot assign to a property of a looped resource declaration. Individual loop iterations cannot be mutated. Set the property in the declaration passed to `fromLoop(loop, ...)`"
+  );
+}
+function createIndexedResourceProxy(resource, index) {
+  const resourceIndexExpression = (0, import_expressions.isExpression)(index) ? (0, import_expressions.unwrapExpression)(index) : index;
+  const root = unwrapResourceHandle(resource);
+  const subclassProto = resource.wrappedCtor?.prototype;
+  return new Proxy(resource, {
+    // Deliberately NO `getPrototypeOf` trap. Exposing the subclass
+    // prototype here would make `proxy instanceof Subclass` report `true`,
+    // invoking subclass getters/methods against the bare `LoopedResource`
+    // target (which lacks the subclass's own instance slots). Property
+    // reads and writes don't need it: the `get`/`set` traps below have
+    // their own `subclassProto` fallbacks that run accessors with
+    // `this = receiver` (the proxy) so `this.expr(...)` resolves against the
+    // indexed element.
+    get(target, property, receiver) {
+      if (property === PROXY_INDEX_REF) return resourceIndexExpression;
+      if (property === INDEXED_PROXY_TARGET) return target;
+      if (property === "expr") {
+        return function boundIndexedExpr(...path) {
+          return createResourceMemberProxy(
+            {
+              resource: target,
+              root,
+              index: resourceIndexExpression
+            },
+            path
+          );
+        };
+      }
+      if (property === "setProperty") {
+        return throwLoopedElementWriteError;
+      }
+      if (property in target) {
+        const value = Reflect.get(target, property, target);
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+      if (subclassProto !== void 0) {
+        let proto = subclassProto;
+        while (proto !== null && proto !== Object.prototype) {
+          const descriptor = Object.getOwnPropertyDescriptor(proto, property);
+          if (descriptor !== void 0) {
+            if (descriptor.get !== void 0) {
+              return descriptor.get.call(receiver);
+            }
+            const value = descriptor.value;
+            return typeof value === "function" ? value.bind(target) : value;
+          }
+          proto = Object.getPrototypeOf(proto);
+        }
+      }
+      return void 0;
+    },
+    // Route writes to an ARM property setter with `this = receiver` (the
+    // proxy), allowing its `setProperty` call to hit the rejection above.
+    // Falls back to a plain write on the raw target.
+    set(target, property, value, receiver) {
+      if (subclassProto !== void 0) {
+        let proto = subclassProto;
+        while (proto !== null && proto !== Object.prototype) {
+          const descriptor = Object.getOwnPropertyDescriptor(proto, property);
+          if (descriptor !== void 0) {
+            if (descriptor.set !== void 0) {
+              descriptor.set.call(receiver, value);
+              return true;
+            }
+            break;
+          }
+          proto = Object.getPrototypeOf(proto);
+        }
+      }
+      return Reflect.set(target, property, value, target);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INDEXED_PROXY_TARGET,
+  LOOPED_RESOURCE_BRAND,
+  PROXY_INDEX_REF,
+  RAW_RESOURCE_HANDLE,
+  RESOURCE_BRAND,
+  RESOURCE_DECLARATION_BRAND,
+  STATE_PARENT_INDEX,
+  createIndexedResourceProxy,
+  createResourceMemberProxy,
+  createResourceProxy,
+  deref,
+  normalizeAssignedValue,
+  unwrapResourceHandle
+});
+//# sourceMappingURL=resource-proxy.js.map

package/dist/commonjs/constructs/resource/resource-proxy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/constructs/resource/resource-proxy.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport {\n  EXPRESSION_BRAND,\n  isExpression,\n  unwrapExpression,\n  type Expression,\n  type ExpressionOrValue,\n} from \"../../expression/expressions.js\";\nimport {\n  accessExpressionNode,\n  arrayAccessExpressionNode,\n  identifierExpressionNode,\n  isExpressionNode,\n  type ArrayAccessIndex,\n  type ExpressionNode,\n} from \"../../expression/ast-nodes.js\";\nimport type { PropertySegment } from \"../../types.js\";\nimport type { LoopedResource, Resource, ResourceDeclaration } from \"./resource.js\";\nimport { navigateShape, type FlatModelShape, type NavShape } from \"../../shape/shape.js\";\nimport { getShape } from \"../../shape/shape-registry.js\";\n\nexport const RAW_RESOURCE_HANDLE = Symbol(\"raw-resource-handle\");\nexport const RESOURCE_BRAND = Symbol.for(\"@azure/provisioning-core.Resource\");\n\n/**\n * Brand present on every `LoopedResource` instance. Lives here (rather than\n * on the `LoopedResource` class) so tree-walking utilities can brand-check\n * for looped declarations without a runtime import of `resource.ts` \u2014 which\n * would create an eval-time import cycle (`resource.ts` extends `ProvisioningComponent`).\n * Use {@link isLoopedResource} in normal code.\n */\nexport const LOOPED_RESOURCE_BRAND = Symbol.for(\"@azure/provisioning-core.LoopedResource\");\n\n/**\n * Brand present on every `ResourceDeclaration` instance (both scalar\n * `Resource` and looped `LoopedResource`). Use\n * {@link isResourceDeclaration} instead of a direct\n * brand check.\n */\nexport const RESOURCE_DECLARATION_BRAND = Symbol.for(\n  \"@azure/provisioning-core.ResourceDeclaration\",\n);\n\n/**\n * Present on indexed resource proxies (see {@link createIndexedResourceProxy}).\n * Reading it off any resource-like value returns the stored index expression\n * for indexed proxies, and `undefined` for plain outer proxies. The base\n * `Resource` constructor probes for it on the `context` argument to detect\n * `parents.at(i)` / `parents.current()` being passed as a child parent\n * context; other consumers may probe it for their own purposes (the proxy\n * itself doesn't imply any parent-child relationship \u2014 the index is simply\n * what identifies which element of a looped declaration this proxy refers\n * to).\n */\nexport const PROXY_INDEX_REF = Symbol.for(\"@azure/provisioning-core.PROXY_INDEX_REF\");\n\n/**\n * Present on indexed resource proxies. Reading it returns the underlying\n * outer-proxy resource that the indexed proxy wraps. Used by the base\n * `Resource` constructor to normalize `this.parent` back to the raw parent\n * (so tree walks and symbol-map lookups continue to work) while\n * `PROXY_INDEX_REF` carries the \"which index\" information onto `state`.\n */\nexport const INDEXED_PROXY_TARGET = Symbol.for(\"@azure/provisioning-core.INDEXED_PROXY_TARGET\");\n\n/**\n * State-object key under which the base `Resource` constructor records the\n * index expression when the `context` argument is an indexed proxy (i.e.,\n * `parent.at(i)` / `parent.current()`). The serializer reads this key\n * from the child's raw state to emit `parent: parentSym[<index>]` instead\n * of the bare `parent: parentSym` form. Kept as a shared const so writer\n * (`resource.ts`) and reader (`serialize.ts`) never drift.\n *\n * Lives on the **child**, not the parent: siblings under the same parent\n * can be created via different indexed proxies (e.g. `new Child(p.at(0), \u2026)`\n * and `new Child(p.at(1), \u2026)` both resolve `.parent` to the same raw parent,\n * so the index that distinguishes them must be recorded per-child).\n */\nexport const STATE_PARENT_INDEX = \"parentIndex\" as const;\n\n// ---------------------------------------------------------------------------\n// Property proxy internal types\n// ---------------------------------------------------------------------------\n\n/**\n * A single step in a property proxy's walk from the root resource. Each step\n * carries the path segment (member name or array index) and the ARM\n * `PropertyShape` stamp's `armPath` for that step (if known). The parallel `path`/`stamps`\n * arrays this replaces could drift in length; a single array of steps makes\n * the invariant structural.\n */\ninterface PropertyStep {\n  readonly segment: PropertySegment;\n  readonly armPath?: readonly string[] | undefined;\n}\n\n/**\n * The identity a member-proxy needs to lower into a Bicep expression and to\n * back reads/writes. Bundles the three roles that were previously passed\n * positionally to {@link createResourceMemberProxy}:\n *\n * - `resource` \u2014 the tree-registered declaration that supplies BOTH the\n *   symbol root (`identifierExpressionNode(resource)`) and the ARM shape\n *   source (`getResourceShape`). For a scalar resource this is the outer\n *   resource proxy; for an indexed looped element it is the raw\n *   `LoopedResource` declaration (the tree citizen), NOT the ephemeral\n *   `.at(i)` handle \u2014 that handle isn't in the component tree, so it can't\n *   resolve to a Bicep symbol.\n * - `root` \u2014 the raw backing object that stores assigned values, used by\n *   `deref(...)` and nested writes.\n * - `index` \u2014 optional array index. When set, the emitted expression roots\n *   at `resource[index]` instead of `resource`, so `many.at(i).prop.blob`\n *   serializes as `sym[i].prop.blob`. Populated for `.at(i)` / `.current()`\n *   handles by {@link createIndexedResourceProxy}.\n */\nexport interface ResourceProxySource {\n  readonly resource: Resource;\n  readonly root: Record<string, unknown>;\n  readonly index?: ArrayAccessIndex;\n}\n\ninterface PropertyProxyState extends ResourceProxySource {\n  // The member/index path from the root resource to the current proxied value,\n  // each entry paired with its wire `armPath` stamp (if known).\n  readonly steps: readonly PropertyStep[];\n  // Current ARM shape navigation state. `undefined` at any level means\n  // \"untyped from here down\"; subsequent accesses are passthrough.\n  readonly nav?: NavShape;\n}\n\nfunction stepsToPath(steps: readonly PropertyStep[]): readonly PropertySegment[] {\n  return steps.map((s) => s.segment);\n}\n\nconst PROPERTY_PROXY_STATE = Symbol(\"property-proxy-state\");\n\nfunction isPropertyProxy(\n  value: unknown,\n): value is { readonly [PROPERTY_PROXY_STATE]: PropertyProxyState } {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    Reflect.get(value as object, PROPERTY_PROXY_STATE) !== undefined\n  );\n}\n\nfunction getPropertyProxyState(value: {\n  readonly [PROPERTY_PROXY_STATE]: PropertyProxyState;\n}): PropertyProxyState {\n  return value[PROPERTY_PROXY_STATE];\n}\n\n// ---------------------------------------------------------------------------\n// Deref\n// ---------------------------------------------------------------------------\n\nexport type Deref<T> = T extends Expression<infer U> ? U : T;\n\nexport function deref<T>(value: T): Deref<T> {\n  if (isPropertyProxy(value)) {\n    const state = getPropertyProxyState(value);\n    return getValueAtPath(state.root, stepsToPath(state.steps)) as Deref<T>;\n  }\n\n  if (isResourceHandle(value)) {\n    return unwrapResourceHandle(value) as Deref<T>;\n  }\n\n  return value as Deref<T>;\n}\n\n// ---------------------------------------------------------------------------\n// Path helpers\n// ---------------------------------------------------------------------------\n\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n}\n\nfunction getValueAtPath(root: Record<string, unknown>, path: readonly PropertySegment[]): unknown {\n  let current: unknown = root;\n\n  for (const segment of path) {\n    if (typeof current !== \"object\" || current === null) {\n      return undefined;\n    }\n\n    if (!Object.prototype.hasOwnProperty.call(current, String(segment))) {\n      return undefined;\n    }\n    current = (current as Record<string, unknown>)[String(segment)];\n  }\n\n  return current;\n}\n\nfunction setValueAtPath(\n  root: Record<string, unknown>,\n  path: readonly PropertySegment[],\n  value: unknown,\n): void {\n  let current: Record<string, unknown> = root;\n\n  for (let index = 0; index < path.length - 1; index += 1) {\n    const segment = String(path[index]);\n    const nextSegment = path[index + 1];\n    const existing = Object.prototype.hasOwnProperty.call(current, segment)\n      ? current[segment]\n      : undefined;\n\n    if (typeof existing === \"object\" && existing !== null) {\n      current = existing as Record<string, unknown>;\n      continue;\n    }\n\n    const container = (typeof nextSegment === \"number\" ? [] : Object.create(null)) as Record<\n      string,\n      unknown\n    >;\n    Object.defineProperty(current, segment, {\n      value: container,\n      enumerable: true,\n      configurable: true,\n      writable: true,\n    });\n    current = container;\n  }\n\n  Object.defineProperty(current, String(path[path.length - 1]), {\n    value,\n    enumerable: true,\n    configurable: true,\n    writable: true,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Expression construction\n// ---------------------------------------------------------------------------\n\nfunction createMemberAccessPathExpression(\n  resource: Resource,\n  steps: readonly PropertyStep[],\n  index?: ArrayAccessIndex,\n): ExpressionNode {\n  let current: ExpressionNode = identifierExpressionNode(resource);\n  if (index !== undefined) {\n    current = arrayAccessExpressionNode(current, index);\n  }\n  for (const { segment, armPath } of steps) {\n    current = accessExpressionNode(current, segment, { armPath });\n  }\n  return current;\n}\n\n// ---------------------------------------------------------------------------\n// Value normalization\n// ---------------------------------------------------------------------------\n\nexport function normalizeAssignedValue(value: unknown, currentResource?: Resource): unknown {\n  if (isPropertyProxy(value)) {\n    const state = getPropertyProxyState(value);\n    if (currentResource && state.resource === currentResource) {\n      // Same-resource proxy \u2192 inline raw value (avoids self-references)\n      return getValueAtPath(state.root, stepsToPath(state.steps));\n    }\n    return createMemberAccessPathExpression(state.resource, state.steps, state.index);\n  }\n\n  if (isResourceHandle(value)) {\n    return identifierExpressionNode(value);\n  }\n\n  if (isExpression(value)) {\n    return unwrapExpression(value);\n  }\n\n  if (isExpressionNode(value)) {\n    return value;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => normalizeAssignedValue(item, currentResource));\n  }\n\n  if (isPlainObject(value)) {\n    return normalizeObjectValue(value as Record<string, unknown>, currentResource);\n  }\n\n  return value;\n}\n\nfunction normalizeObjectValue(\n  obj: Record<string, unknown>,\n  currentResource?: Resource,\n): Record<string, unknown> {\n  const entries = Object.entries(obj);\n  const result: Record<string, unknown> = Object.create(null);\n\n  for (const [key, value] of entries) {\n    if (isPropertyProxy(value)) {\n      const state = getPropertyProxyState(value);\n      if (currentResource && state.resource === currentResource) {\n        // Same-resource \u2192 inline raw value (avoids self-references)\n        result[key] = getValueAtPath(state.root, stepsToPath(state.steps));\n        continue;\n      }\n    }\n\n    result[key] = normalizeAssignedValue(value, currentResource);\n  }\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Property proxy\n// ---------------------------------------------------------------------------\n\nfunction toPropertySegment(\n  property: string,\n  nav: NavShape,\n  currentValue: unknown,\n): PropertySegment {\n  const isIndexedContainer =\n    nav?.kind === \"array\" || nav?.kind === \"tuple\" || Array.isArray(currentValue);\n  return isIndexedContainer && /^\\d+$/u.test(property) ? Number(property) : property;\n}\n\nfunction getPropertyProxyTarget(state: PropertyProxyState): object {\n  const currentValue = getValueAtPath(state.root, stepsToPath(state.steps));\n\n  if (typeof currentValue === \"object\" && currentValue !== null) {\n    return currentValue;\n  }\n\n  return {};\n}\n\nfunction createPropertyProxy(state: PropertyProxyState): unknown {\n  // Always use a fresh empty target \u2014 avoids Proxy invariant violations\n  // when the stored value has non-configurable properties (e.g. EXPRESSION_BRAND).\n  const target = {};\n\n  return new Proxy(target, {\n    has(proxyTarget, property) {\n      if (property === PROPERTY_PROXY_STATE || property === EXPRESSION_BRAND) {\n        return true;\n      }\n\n      const backing = getPropertyProxyTarget(state);\n      if (Reflect.has(backing, property)) return true;\n      return Reflect.has(proxyTarget, property);\n    },\n\n    ownKeys() {\n      const backing = getPropertyProxyTarget(state);\n      return Reflect.ownKeys(backing).filter((k): k is string => typeof k === \"string\");\n    },\n\n    getOwnPropertyDescriptor(_proxyTarget, property) {\n      const backing = getPropertyProxyTarget(state);\n      if (typeof property === \"string\" && Object.prototype.hasOwnProperty.call(backing, property)) {\n        return { enumerable: true, configurable: true, writable: true };\n      }\n      return undefined;\n    },\n\n    get(proxyTarget, property, receiver) {\n      if (property === PROPERTY_PROXY_STATE) {\n        return state;\n      }\n\n      if (property === EXPRESSION_BRAND) {\n        return createMemberAccessPathExpression(state.resource, state.steps, state.index);\n      }\n\n      if (property === Symbol.toPrimitive) {\n        return () => `[ResourceMember ${stepsToPath(state.steps).map(String).join(\".\")}]`;\n      }\n\n      if (typeof property !== \"string\") {\n        return Reflect.get(proxyTarget, property, receiver);\n      }\n\n      if (property === \"toString\") {\n        return () => `[ResourceMember ${stepsToPath(state.steps).map(String).join(\".\")}]`;\n      }\n\n      if (property === \"valueOf\") {\n        return () => createMemberAccessPathExpression(state.resource, state.steps, state.index);\n      }\n\n      if (property === \"then\") {\n        return undefined;\n      }\n\n      const currentValue = getValueAtPath(state.root, stepsToPath(state.steps));\n      const segment = toPropertySegment(property, state.nav, currentValue);\n      // Pass the value at the current position so a discriminated nav\n      // can select its variant (see `resolveModelShape`).\n      const step = navigateShape(state.nav, segment, currentValue);\n      const nextArmPath = step.stamp?.armPath;\n      const nextNav = step.next;\n\n      return createPropertyProxy({\n        ...state,\n        steps: [...state.steps, { segment, armPath: nextArmPath }],\n        nav: nextNav,\n      });\n    },\n\n    set(_proxyTarget, property, value) {\n      if (typeof property !== \"string\") {\n        return false;\n      }\n\n      // A looped element (`parent.at(i)`) yields member proxies stamped with\n      // an index. Writing through one would mutate the shared for-loop body,\n      // which is not valid Bicep \u2014 `sym[i].prop = ...` cannot be expressed.\n      if (state.index !== undefined) {\n        throwLoopedElementWriteError();\n      }\n\n      setValueAtPath(\n        state.root,\n        [\n          ...stepsToPath(state.steps),\n          toPropertySegment(\n            property,\n            state.nav,\n            getValueAtPath(state.root, stepsToPath(state.steps)),\n          ),\n        ],\n        normalizeAssignedValue(value, state.resource),\n      );\n\n      return true;\n    },\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Resource member proxy\n// ---------------------------------------------------------------------------\n\nfunction isNonEnumerableOwnProperty(target: object, property: string): boolean {\n  const descriptor = Reflect.getOwnPropertyDescriptor(target, property);\n  return descriptor?.enumerable === false;\n}\n\nfunction hasOwnOrPrototypeProperty(target: object, property: string): boolean {\n  let current: object | null = target;\n\n  while (current !== null) {\n    if (Object.prototype.hasOwnProperty.call(current, property)) {\n      return true;\n    }\n    current = Object.getPrototypeOf(current);\n  }\n\n  return false;\n}\n\nexport function createResourceMemberProxy<TValue>(\n  source: ResourceProxySource,\n  path: readonly PropertySegment[],\n): Expression<TValue> & TValue {\n  // Seed nav from the resource's shape (if any). Walk the existing\n  // path, transitioning nav at each step so every segment is stamped\n  // correctly. Pre-existing callers pass paths they built manually, so\n  // we treat unknown navigations as passthrough.\n  const rootShape = getResourceShape(source.resource);\n  let nav: NavShape = rootShape;\n  const steps: PropertyStep[] = [];\n  for (const segment of path) {\n    const step = navigateShape(nav, segment, getValueAtPath(source.root, stepsToPath(steps)));\n    steps.push({ segment, armPath: step.stamp?.armPath });\n    nav = step.next;\n  }\n\n  return createPropertyProxy({\n    ...source,\n    steps,\n    nav,\n  }) as Expression<TValue> & TValue;\n}\n\nfunction getResourceShape(resource: Resource): FlatModelShape | undefined {\n  // Look up by (armType, apiVersion), letting the registry resolve\n  // any discriminated variant from the instance's own state (typically\n  // the hardcoded `name` literal each variant class sets).\n  const state = (resource as unknown as { [RAW_RESOURCE_HANDLE]: Record<string, unknown> })[\n    RAW_RESOURCE_HANDLE\n  ];\n  return getShape(resource.type, resource.apiVersion, state);\n}\n\n// ---------------------------------------------------------------------------\n// Resource-level proxy\n// ---------------------------------------------------------------------------\n\nexport function createResourceProxy<\n  TType extends string,\n  TResource extends Resource<TType> & object,\n>(resource: TResource): TResource {\n  function getBackingResourceData(target: TResource): Record<string, unknown> {\n    return Reflect.get(target, RAW_RESOURCE_HANDLE) as Record<string, unknown>;\n  }\n\n  const proxy = new Proxy(resource, {\n    ownKeys(target) {\n      return Array.from(\n        new Set([\n          ...Reflect.ownKeys(target),\n          ...Reflect.ownKeys(getBackingResourceData(target)).filter(\n            (key) => key !== RAW_RESOURCE_HANDLE,\n          ),\n        ]),\n      );\n    },\n\n    getOwnPropertyDescriptor(target, property) {\n      const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, property);\n      if (targetDescriptor !== undefined) {\n        return targetDescriptor;\n      }\n\n      const backing = getBackingResourceData(target);\n      if (Object.prototype.hasOwnProperty.call(backing, property)) {\n        return { enumerable: true, configurable: true, writable: true };\n      }\n\n      return undefined;\n    },\n\n    get(target, property, receiver) {\n      if (typeof property !== \"string\") {\n        return Reflect.get(target, property, receiver);\n      }\n\n      if (property === \"then\") {\n        return Reflect.get(target, property, receiver);\n      }\n\n      if (\n        hasOwnOrPrototypeProperty(target, property) ||\n        isNonEnumerableOwnProperty(target, property)\n      ) {\n        return Reflect.get(target, property, receiver);\n      }\n\n      const rootState = unwrapResourceHandle(proxy) as Record<string, unknown>;\n      const rootShape = getResourceShape(target);\n      const segment = toPropertySegment(property, rootShape, rootState);\n      const step = navigateShape(rootShape, segment, rootState);\n      const armPath = step.stamp?.armPath;\n      const nav = step.next;\n\n      return createPropertyProxy({\n        resource: proxy,\n        root: rootState,\n        steps: [{ segment, armPath }],\n        nav,\n      });\n    },\n\n    set(target, property, value, receiver) {\n      if (typeof property !== \"string\") {\n        return Reflect.set(target, property, value, receiver);\n      }\n\n      if (\n        hasOwnOrPrototypeProperty(target, property) ||\n        isNonEnumerableOwnProperty(target, property)\n      ) {\n        return Reflect.set(target, property, value, receiver);\n      }\n\n      setValueAtPath(\n        unwrapResourceHandle(proxy) as Record<string, unknown>,\n        [toPropertySegment(property, getResourceShape(target), unwrapResourceHandle(proxy))],\n        normalizeAssignedValue(value, proxy),\n      );\n      return true;\n    },\n  });\n\n  return proxy;\n}\n\n// ---------------------------------------------------------------------------\n// Resource handle detection\n// ---------------------------------------------------------------------------\n\nfunction isResourceHandle(value: unknown): value is Resource {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    (value as Record<symbol, unknown>)[RESOURCE_BRAND] === true\n  );\n}\n\nexport function unwrapResourceHandle<T extends ResourceDeclaration>(resource: T): T {\n  const maybeRaw = Reflect.get(resource as object, RAW_RESOURCE_HANDLE);\n\n  if (maybeRaw === undefined) {\n    return resource;\n  }\n\n  return maybeRaw as T;\n}\n\n// ---------------------------------------------------------------------------\n// Indexed resource proxy \u2014 for `LoopedResource.at(i)` / `.current()`\n// ---------------------------------------------------------------------------\n\n/**\n * Returns a passthrough proxy over `resource` that carries an \"index\"\n * expression alongside the wrapped resource. Two purposes:\n *\n * 1. **Property reads** \u2014 ARM getters on the underlying `Resource` funnel\n *    through `this.expr(...)`. The indexed proxy intercepts `expr` and\n *    threads `resourceIndexExpression` into the member proxy so that reads\n *    render as `sym[index].<path>` on the wire. Direct data-property reads\n *    like `.type` / `.apiVersion` / `.condition` / `.existing` fall through\n *    unchanged (they are authoring/type metadata, not ARM reads).\n *\n * 2. **Child parent context** \u2014 passing `parents.at(0)` as the first\n *    argument to a child constructor must (a) let the child register into\n *    the raw parent's tree, and (b) record the index so the serializer can\n *    emit `parent: parentSym[i]`.\n *    This proxy passes framework members (`children`, `deploymentContext`,\n *    `_localDeploymentContext`, `hasDeploymentContext`, `.parent`, `.self`,\n *    ...) through unchanged so the base `Resource` constructor's\n *    interaction with `context` works exactly as it would with the raw\n *    parent. `PROXY_INDEX_REF` and `INDEXED_PROXY_TARGET` expose the\n *    index and the raw target to the base `Resource` constructor.\n *\n * The `index` can be a literal number, a literal string, or any expression\n * (typically a loop's `.index` symbolic value). It is unwrapped from any\n * `Expression<T>` proxy at construction time so downstream code stores a\n * primitive or an `ExpressionNode`, never an `Expression` proxy.\n *\n * **The indexed proxy is an ephemeral wrapper, not a tree node.** A fresh\n * proxy is minted per `.at(i)` call and is not stored in\n * any `parent.children` array; only the raw outer resource proxy\n * participates in the ProvisioningComponent tree. When a child is created with an\n * indexed proxy as `context`, `ProvisioningComponent`'s ctor writes\n * `this.parent = indexedProxy` briefly, but the base `Resource` ctor then overwrites\n * `this.parent` back to the raw parent (via `INDEXED_PROXY_TARGET`) so the\n * tree only ever references raw resource proxies. The indexed wrapper is\n * garbage-collectable once the child ctor returns; its sole job is to\n * carry the index through construction into `state.parentIndex`.\n */\n/**\n * Static type an indexed proxy exposes, derived from the declaration it\n * wraps. A `LoopedResource<T>` narrows to `T` \u2014 the concrete resource\n * type \u2014 so `parent.at(i)` exposes the full ARM and child-accessor\n * surface, resolved element-scoped at runtime. Any scalar {@link Resource}\n * yields itself.\n */\ntype IndexedProxyOf<D extends ResourceDeclaration> = D extends LoopedResource<infer T> ? T : D;\n\nfunction throwLoopedElementWriteError(): never {\n  throw new Error(\n    \"Cannot assign to a property of a looped resource declaration. Individual loop iterations cannot be mutated. Set the property in the declaration passed to `fromLoop(loop, ...)`\",\n  );\n}\n\nexport function createIndexedResourceProxy<D extends ResourceDeclaration>(\n  resource: D,\n  index: ExpressionOrValue<number>,\n): IndexedProxyOf<D> {\n  const resourceIndexExpression: ArrayAccessIndex = isExpression(index)\n    ? unwrapExpression(index as Expression<number>)\n    : index;\n  const root = unwrapResourceHandle(resource) as unknown as Record<string, unknown>;\n\n  // A looped declaration (`LoopedResource`) exposes the concrete subclass\n  // ctor it wraps via `wrappedCtor`; its prototype carries the subclass's\n  // ARM accessors (`.sku`, `.properties.*`, `.id`, `.name`). The `get` trap\n  // below walks this prototype to resolve those reads rooted at\n  // `sym[index]`. A scalar `Resource` has no `wrappedCtor` \u2014 it already\n  // carries those accessors on its own prototype, so `subclassProto` stays\n  // `undefined` and lookups resolve via the target's own chain.\n  const subclassProto = (resource as { readonly wrappedCtor?: { readonly prototype: object } })\n    .wrappedCtor?.prototype;\n\n  return new Proxy(resource as object, {\n    // Deliberately NO `getPrototypeOf` trap. Exposing the subclass\n    // prototype here would make `proxy instanceof Subclass` report `true`,\n    // invoking subclass getters/methods against the bare `LoopedResource`\n    // target (which lacks the subclass's own instance slots). Property\n    // reads and writes don't need it: the `get`/`set` traps below have\n    // their own `subclassProto` fallbacks that run accessors with\n    // `this = receiver` (the proxy) so `this.expr(...)` resolves against the\n    // indexed element.\n    get(target, property, receiver) {\n      // Reveal-only symbols consulted by the base `Resource` constructor\n      // and by serialization; both are marker keys with no runtime prototype\n      // representation on plain resources.\n      if (property === PROXY_INDEX_REF) return resourceIndexExpression;\n      if (property === INDEXED_PROXY_TARGET) return target;\n\n      // Intercept the single funnel for ARM reads. `this.expr(...path)` is\n      // the getter body used by every generated ARM property (`.name`,\n      // `.id`, `.properties.*`, etc.). Route it through\n      // `createResourceMemberProxy` with our `resourceIndexExpression` so\n      // the whole emitted expression roots at `sym[index]` instead of `sym`.\n      if (property === \"expr\") {\n        return function boundIndexedExpr(...path: readonly PropertySegment[]): unknown {\n          return createResourceMemberProxy(\n            {\n              resource: target as Resource,\n              root,\n              index: resourceIndexExpression,\n            },\n            path,\n          );\n        };\n      }\n\n      // Block ARM property writes on a looped element. Every generated ARM\n      // setter (`set sku`, `set properties`, `set name`, \u2026) funnels through\n      // `this.setProperty(...)`, so intercepting that single method turns\n      // `parent.at(i).sku = ...` into a clear error.\n      if (property === \"setProperty\") {\n        return throwLoopedElementWriteError;\n      }\n\n      // First try the target's own chain. Two subtleties:\n      //\n      // 1. Getters (`.type`, `.apiVersion`, `.children`, `.parent`, \u2026) must\n      //    run with `this = target` so they see the raw resource's own\n      //    properties \u2014 including class private fields (`#\u2026`). Passing the\n      //    proxy as `receiver` would cause private-field access inside a\n      //    getter to fail because the proxy has no such slot.\n      // 2. Subclass methods need `this = target` for the same reason \u2014 private\n      //    fields again \u2014 so\n      //    we return a bound wrapper. This means `ctx.method === ctx.method`\n      //    yields `false` between reads; acceptable trade-off given no\n      //    caller relies on function identity on an indexed proxy.\n      if (property in target) {\n        const value = Reflect.get(target, property, target);\n        return typeof value === \"function\" ? value.bind(target) : value;\n      }\n\n      // Fall through to `subclassProto` for subclass-specific getters\n      // (e.g. `.id`, `.name`, `.sku`) when wrapping a `LoopedResource`.\n      // Getters must run with `this = receiver` (the proxy) so their\n      // `this.expr(...)` calls hit our intercept above, yielding an\n      // expression rooted at `sym[index]`. Methods bind to `target` to\n      // stay consistent with the passthrough branch above.\n      if (subclassProto !== undefined) {\n        let proto: object | null = subclassProto;\n        while (proto !== null && proto !== Object.prototype) {\n          const descriptor = Object.getOwnPropertyDescriptor(proto, property);\n          if (descriptor !== undefined) {\n            if (descriptor.get !== undefined) {\n              return descriptor.get.call(receiver);\n            }\n            const value = descriptor.value;\n            return typeof value === \"function\" ? value.bind(target) : value;\n          }\n          proto = Object.getPrototypeOf(proto);\n        }\n      }\n\n      return undefined;\n    },\n\n    // Route writes to an ARM property setter with `this = receiver` (the\n    // proxy), allowing its `setProperty` call to hit the rejection above.\n    // Falls back to a plain write on the raw target.\n    set(target, property, value, receiver) {\n      if (subclassProto !== undefined) {\n        let proto: object | null = subclassProto;\n        while (proto !== null && proto !== Object.prototype) {\n          const descriptor = Object.getOwnPropertyDescriptor(proto, property);\n          if (descriptor !== undefined) {\n            if (descriptor.set !== undefined) {\n              descriptor.set.call(receiver, value);\n              return true;\n            }\n            break;\n          }\n          proto = Object.getPrototypeOf(proto);\n        }\n      }\n      return Reflect.set(target, property, value, target);\n    },\n  }) as IndexedProxyOf<D>;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/commonjs/constructs/resource/resource-query.d.ts

@@ -0,0 +1,23 @@
+import type { ProvisioningComponent } from "../provisioning-component.js";
+import type { LoopedResource, Resource } from "./resource.js";
+import type { ResourceCtor } from "./resource-registry.js";
+/** Options accepted by the `Stack` resource queries. */
+export interface QueryOptions {
+    /**
+     * Whether to walk the stack's entire subtree (default `true`) or only its
+     * **direct children** (`false`).
+     */
+    readonly recursive?: boolean;
+}
+/** Scalar (un-looped) resource declarations. */
+export declare function getResources(root: ProvisioningComponent, typeOrOptions?: ResourceCtor<Resource> | QueryOptions, maybeOptions?: QueryOptions): Resource[];
+/** Loop-expanded resource declarations (`Ctor.fromLoop(...)`). */
+export declare function getLoopedResources(root: ProvisioningComponent, typeOrOptions?: ResourceCtor<Resource> | QueryOptions, maybeOptions?: QueryOptions): LoopedResource<Resource>[];
+/**
+ * First scalar resource of `type` whose literal name equals `name`, or
+ * `undefined`. `deref` resolves the name's expression proxy to its literal
+ * (a `Resource`'s `name` is an `Expression`, so `r.name === name` is always
+ * false without it).
+ */
+export declare function getResource<T extends Resource>(root: ProvisioningComponent, type: ResourceCtor<T>, name: string, options?: QueryOptions): T | undefined;
+//# sourceMappingURL=resource-query.d.ts.map

package/dist/commonjs/constructs/resource/resource-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-query.d.ts","sourceRoot":"","sources":["../../../../src/constructs/resource/resource-query.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAM3D,wDAAwD;AACxD,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAsCD,gDAAgD;AAChD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,qBAAqB,EAC3B,aAAa,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,YAAY,EACrD,YAAY,CAAC,EAAE,YAAY,GAC1B,QAAQ,EAAE,CAOZ;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,qBAAqB,EAC3B,aAAa,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,GAAG,YAAY,EACrD,YAAY,CAAC,EAAE,YAAY,GAC1B,cAAc,CAAC,QAAQ,CAAC,EAAE,CAO5B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAC5C,IAAI,EAAE,qBAAqB,EAC3B,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EACrB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,GACrB,CAAC,GAAG,SAAS,CAKf"}

package/dist/commonjs/constructs/resource/resource-query.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resource_query_exports = {};
+__export(resource_query_exports, {
+  getLoopedResources: () => getLoopedResources,
+  getResource: () => getResource,
+  getResources: () => getResources
+});
+module.exports = __toCommonJS(resource_query_exports);
+var import_resource_utils = require("./resource-utils.js");
+var import_resource_proxy = require("./resource-proxy.js");
+function collectResourcesUnder(root, wantLooped, recursive) {
+  const result = [];
+  const consider = (node) => {
+    if (!(0, import_resource_utils.isResourceDeclaration)(node)) return;
+    const r = node.self;
+    if ((0, import_resource_utils.isLoopedResource)(r) === wantLooped) result.push(r);
+  };
+  for (const child of root.children) {
+    if (recursive) child.visit(consider);
+    else consider(child);
+  }
+  return result;
+}
+function getResources(root, typeOrOptions, maybeOptions) {
+  const isCtor = typeof typeOrOptions === "function";
+  const type = isCtor ? typeOrOptions : void 0;
+  const options = isCtor ? maybeOptions : typeOrOptions;
+  const recursive = options?.recursive ?? true;
+  const found = collectResourcesUnder(root, false, recursive);
+  return type === void 0 ? found : found.filter((r) => r instanceof type);
+}
+function getLoopedResources(root, typeOrOptions, maybeOptions) {
+  const isCtor = typeof typeOrOptions === "function";
+  const type = isCtor ? typeOrOptions : void 0;
+  const options = isCtor ? maybeOptions : typeOrOptions;
+  const recursive = options?.recursive ?? true;
+  const found = collectResourcesUnder(root, true, recursive);
+  return type === void 0 ? found : found.filter((r) => (0, import_resource_utils.isLoopedResourceOf)(r, type));
+}
+function getResource(root, type, name, options) {
+  for (const r of getResources(root, type, options)) {
+    if ((0, import_resource_proxy.deref)(r.name) === name) return r;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoopedResources,
+  getResource,
+  getResources
+});
+//# sourceMappingURL=resource-query.js.map