@azure/provisioning-core 0.1.0-alpha.20261026.1 → 1.0.0-beta.2

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

@@ -0,0 +1,134 @@
+import { type Expression, type ExpressionOrValue } from "../../expression/expressions.js";
+import { type ArrayAccessIndex } from "../../expression/ast-nodes.js";
+import type { PropertySegment } from "../../types.js";
+import type { LoopedResource, Resource, ResourceDeclaration } from "./resource.js";
+export declare const RAW_RESOURCE_HANDLE: unique symbol;
+export declare const RESOURCE_BRAND: unique symbol;
+/**
+ * Brand present on every `LoopedResource` instance. Lives here (rather than
+ * on the `LoopedResource` class) so tree-walking utilities can brand-check
+ * for looped declarations without a runtime import of `resource.ts` — which
+ * would create an eval-time import cycle (`resource.ts` extends `ProvisioningComponent`).
+ * Use {@link isLoopedResource} in normal code.
+ */
+export declare const LOOPED_RESOURCE_BRAND: unique symbol;
+/**
+ * Brand present on every `ResourceDeclaration` instance (both scalar
+ * `Resource` and looped `LoopedResource`). Use
+ * {@link isResourceDeclaration} instead of a direct
+ * brand check.
+ */
+export declare const RESOURCE_DECLARATION_BRAND: unique symbol;
+/**
+ * Present on indexed resource proxies (see {@link createIndexedResourceProxy}).
+ * Reading it off any resource-like value returns the stored index expression
+ * for indexed proxies, and `undefined` for plain outer proxies. The base
+ * `Resource` constructor probes for it on the `context` argument to detect
+ * `parents.at(i)` / `parents.current()` being passed as a child parent
+ * context; other consumers may probe it for their own purposes (the proxy
+ * itself doesn't imply any parent-child relationship — the index is simply
+ * what identifies which element of a looped declaration this proxy refers
+ * to).
+ */
+export declare const PROXY_INDEX_REF: unique symbol;
+/**
+ * Present on indexed resource proxies. Reading it returns the underlying
+ * outer-proxy resource that the indexed proxy wraps. Used by the base
+ * `Resource` constructor to normalize `this.parent` back to the raw parent
+ * (so tree walks and symbol-map lookups continue to work) while
+ * `PROXY_INDEX_REF` carries the "which index" information onto `state`.
+ */
+export declare const INDEXED_PROXY_TARGET: unique symbol;
+/**
+ * State-object key under which the base `Resource` constructor records the
+ * index expression when the `context` argument is an indexed proxy (i.e.,
+ * `parent.at(i)` / `parent.current()`). The serializer reads this key
+ * from the child's raw state to emit `parent: parentSym[<index>]` instead
+ * of the bare `parent: parentSym` form. Kept as a shared const so writer
+ * (`resource.ts`) and reader (`serialize.ts`) never drift.
+ *
+ * Lives on the **child**, not the parent: siblings under the same parent
+ * can be created via different indexed proxies (e.g. `new Child(p.at(0), …)`
+ * and `new Child(p.at(1), …)` both resolve `.parent` to the same raw parent,
+ * so the index that distinguishes them must be recorded per-child).
+ */
+export declare const STATE_PARENT_INDEX: "parentIndex";
+/**
+ * The identity a member-proxy needs to lower into a Bicep expression and to
+ * back reads/writes. Bundles the three roles that were previously passed
+ * positionally to {@link createResourceMemberProxy}:
+ *
+ * - `resource` — the tree-registered declaration that supplies BOTH the
+ *   symbol root (`identifierExpressionNode(resource)`) and the ARM shape
+ *   source (`getResourceShape`). For a scalar resource this is the outer
+ *   resource proxy; for an indexed looped element it is the raw
+ *   `LoopedResource` declaration (the tree citizen), NOT the ephemeral
+ *   `.at(i)` handle — that handle isn't in the component tree, so it can't
+ *   resolve to a Bicep symbol.
+ * - `root` — the raw backing object that stores assigned values, used by
+ *   `deref(...)` and nested writes.
+ * - `index` — optional array index. When set, the emitted expression roots
+ *   at `resource[index]` instead of `resource`, so `many.at(i).prop.blob`
+ *   serializes as `sym[i].prop.blob`. Populated for `.at(i)` / `.current()`
+ *   handles by {@link createIndexedResourceProxy}.
+ */
+export interface ResourceProxySource {
+    readonly resource: Resource;
+    readonly root: Record<string, unknown>;
+    readonly index?: ArrayAccessIndex;
+}
+export type Deref<T> = T extends Expression<infer U> ? U : T;
+export declare function deref<T>(value: T): Deref<T>;
+export declare function normalizeAssignedValue(value: unknown, currentResource?: Resource): unknown;
+export declare function createResourceMemberProxy<TValue>(source: ResourceProxySource, path: readonly PropertySegment[]): Expression<TValue> & TValue;
+export declare function createResourceProxy<TType extends string, TResource extends Resource<TType> & object>(resource: TResource): TResource;
+export declare function unwrapResourceHandle<T extends ResourceDeclaration>(resource: T): T;
+/**
+ * Returns a passthrough proxy over `resource` that carries an "index"
+ * expression alongside the wrapped resource. Two purposes:
+ *
+ * 1. **Property reads** — ARM getters on the underlying `Resource` funnel
+ *    through `this.expr(...)`. The indexed proxy intercepts `expr` and
+ *    threads `resourceIndexExpression` into the member proxy so that reads
+ *    render as `sym[index].<path>` on the wire. Direct data-property reads
+ *    like `.type` / `.apiVersion` / `.condition` / `.existing` fall through
+ *    unchanged (they are authoring/type metadata, not ARM reads).
+ *
+ * 2. **Child parent context** — passing `parents.at(0)` as the first
+ *    argument to a child constructor must (a) let the child register into
+ *    the raw parent's tree, and (b) record the index so the serializer can
+ *    emit `parent: parentSym[i]`.
+ *    This proxy passes framework members (`children`, `deploymentContext`,
+ *    `_localDeploymentContext`, `hasDeploymentContext`, `.parent`, `.self`,
+ *    ...) through unchanged so the base `Resource` constructor's
+ *    interaction with `context` works exactly as it would with the raw
+ *    parent. `PROXY_INDEX_REF` and `INDEXED_PROXY_TARGET` expose the
+ *    index and the raw target to the base `Resource` constructor.
+ *
+ * The `index` can be a literal number, a literal string, or any expression
+ * (typically a loop's `.index` symbolic value). It is unwrapped from any
+ * `Expression<T>` proxy at construction time so downstream code stores a
+ * primitive or an `ExpressionNode`, never an `Expression` proxy.
+ *
+ * **The indexed proxy is an ephemeral wrapper, not a tree node.** A fresh
+ * proxy is minted per `.at(i)` call and is not stored in
+ * any `parent.children` array; only the raw outer resource proxy
+ * participates in the ProvisioningComponent tree. When a child is created with an
+ * indexed proxy as `context`, `ProvisioningComponent`'s ctor writes
+ * `this.parent = indexedProxy` briefly, but the base `Resource` ctor then overwrites
+ * `this.parent` back to the raw parent (via `INDEXED_PROXY_TARGET`) so the
+ * tree only ever references raw resource proxies. The indexed wrapper is
+ * garbage-collectable once the child ctor returns; its sole job is to
+ * carry the index through construction into `state.parentIndex`.
+ */
+/**
+ * Static type an indexed proxy exposes, derived from the declaration it
+ * wraps. A `LoopedResource<T>` narrows to `T` — the concrete resource
+ * type — so `parent.at(i)` exposes the full ARM and child-accessor
+ * surface, resolved element-scoped at runtime. Any scalar {@link Resource}
+ * yields itself.
+ */
+type IndexedProxyOf<D extends ResourceDeclaration> = D extends LoopedResource<infer T> ? T : D;
+export declare function createIndexedResourceProxy<D extends ResourceDeclaration>(resource: D, index: ExpressionOrValue<number>): IndexedProxyOf<D>;
+export {};
+//# sourceMappingURL=resource-proxy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource-proxy.d.ts","sourceRoot":"","sources":["../../../../src/constructs/resource/resource-proxy.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAKL,KAAK,gBAAgB,EAEtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAInF,eAAO,MAAM,mBAAmB,eAAgC,CAAC;AACjE,eAAO,MAAM,cAAc,eAAkD,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,eAAwD,CAAC;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,eAEtC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,eAAyD,CAAC;AAEtF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,eAA8D,CAAC;AAEhG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAG,aAAsB,CAAC;AAkBzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAqCD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE7D,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAW3C;AA+FD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,eAAe,CAAC,EAAE,QAAQ,GAAG,OAAO,CA+B1F;AA8KD,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,SAAS,eAAe,EAAE,GAC/B,UAAU,CAAC,MAAM,CAAC,GAAG,MAAM,CAmB7B;AAgBD,wBAAgB,mBAAmB,CACjC,KAAK,SAAS,MAAM,EACpB,SAAS,SAAS,QAAQ,CAAC,KAAK,CAAC,GAAG,MAAM,EAC1C,QAAQ,EAAE,SAAS,GAAG,SAAS,CAoFhC;AAcD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,mBAAmB,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAQlF;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;;;;;;GAMG;AACH,KAAK,cAAc,CAAC,CAAC,SAAS,mBAAmB,IAAI,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAQ/F,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,mBAAmB,EACtE,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAC/B,cAAc,CAAC,CAAC,CAAC,CAwHnB"}

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