@azure/provisioning-core 1.0.0-beta.1

package/dist/esm/constructs/resource/resource.js

@@ -0,0 +1,582 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { ProvisioningComponent } from "../provisioning-component.js";
+import { createBinaryExpression, unwrapExpression, wrapExpression, } from "../../expression/expressions.js";
+import { symbolicValueExpressionNode } from "../../expression/ast-nodes.js";
+import { namingRequiredPolicy, resolveResourceName } from "../../naming/naming-policy.js";
+import { RAW_RESOURCE_HANDLE, RESOURCE_BRAND, RESOURCE_DECLARATION_BRAND, LOOPED_RESOURCE_BRAND, PROXY_INDEX_REF, INDEXED_PROXY_TARGET, STATE_PARENT_INDEX, createIndexedResourceProxy, createResourceMemberProxy, createResourceProxy, normalizeAssignedValue, unwrapResourceHandle, } from "./resource-proxy.js";
+import { isResourceDeclaration } from "./resource-utils.js";
+import { getShape, registerShape as registerShapeInRegistry } from "../../shape/shape-registry.js";
+import { registerResource as registerResourceInRegistry, } from "./resource-registry.js";
+/**
+ * Shared base for resource declaration implementations.
+ *
+ * @remarks
+ *
+ * Both represent one Bicep resource declaration in the component tree and
+ * share the same declaration-level state layout: identity fields
+ * (`type`, `apiVersion`, `existing`), the `if(...)` guard (`condition`),
+ * the optional cross-scope reference (`scope`), and the raw prop bag that
+ * becomes the resource body.
+ *
+ * This class owns the common declaration state layout, raw-handle escape
+ * hatch, and identity accessors. Subclasses supply their construction and
+ * access behavior.
+ */
+export class ResourceDeclaration extends ProvisioningComponent {
+    /**
+     * Brand marker for cross-realm `isResourceDeclaration()` checks. Uses
+     * `Symbol.for` so it survives multiple copies of `@azure/provisioning-core`.
+     * Inherited by every resource declaration implementation.
+     */
+    [RESOURCE_DECLARATION_BRAND] = true;
+    // Not `readonly`: the ctor writes `this.state = data` once. TypeScript
+    // forbids subclass writes to a `readonly` parent field, so the
+    // immutability is a runtime contract (never reassigned after ctor)
+    // rather than a static one.
+    state;
+    /**
+     * Base constructor for every Bicep resource declaration.
+     *
+     * @remarks
+     *
+     * Responsibilities:
+     * 1. Register in the component tree (`super(context)`).
+     * 2. Enforce a deployment context ancestor.
+     * 3. Unwrap `context` if it's an indexed proxy from `.at(i)` /
+     *    `parent.at(loop.index)`, and stash `parentIndex` on `state` so the
+     *    serializer can emit `parent: parentSym[index]` on the child.
+     * 4. Inherit `condition` from the immediate parent resource
+     *    declaration when the caller doesn't supply one (Bicep requires
+     *    children of a conditional resource to share the same guard).
+     * 5. Populate `state` — existing arm records only identity fields;
+     *    deployable arm runs the naming policy and applies
+     *    `DeploymentContext` defaults for `location` / `tags` per the
+     *    shape descriptor.
+     *
+     * Subclasses supply the last mile, including their public handle behavior.
+     *
+     * @param namingRules - per-resource-type constraints for the naming
+     *   policy. `Resource` reads this reflectively off the concrete subclass
+     *   constructor; internal declaration implementations receive it from
+     *   the concrete resource constructor they represent.
+     */
+    constructor(context, props, options, namingRules) {
+        super(context);
+        if (!this.hasDeploymentContext()) {
+            throw new Error("Resource declaration must have a parent deployment context.");
+        }
+        // If `context` is an indexed proxy returned by
+        // `LoopedResource.at(i)`, unwrap `this.parent`
+        // back to the raw parent so tree walks and symbol-map lookups continue
+        // to work, and capture the index so the serializer can emit
+        // `parent: parentSym[index]` on this child. The `ProvisioningComponent` constructor
+        // already pushed `this` into the correct children array (indexed proxy
+        // passes `.children` through to the raw parent's array), so nothing to
+        // fix up there.
+        //
+        // The index is recorded on the child's state (not the parent's) because
+        // siblings can have different indices — `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 per-child.
+        const indexRef = context[PROXY_INDEX_REF];
+        let parentIndex = undefined;
+        if (indexRef !== undefined) {
+            const rawParent = context[INDEXED_PROXY_TARGET];
+            if (rawParent !== undefined) {
+                this.parent = rawParent;
+            }
+            parentIndex = indexRef;
+        }
+        // `existing` lives on `props` (it's the discriminant of the generated
+        // `{ existing?: false } | { existing: true }` union). `condition` is
+        // routed through `options`.
+        //
+        // Bicep requires a child of a conditional resource to itself be
+        // conditional on the same expression. When no explicit `condition` is
+        // supplied, inherit the immediate parent resource declaration's
+        // condition so the emitted template stays valid — child authoring
+        // shouldn't have to redundantly restate the parent's guard.
+        const isExisting = props.existing === true;
+        const parent = this.parent;
+        const inheritedCondition = isResourceDeclaration(parent)
+            ? parent.self.state["condition"]
+            : undefined;
+        const explicitCondition = options?.condition;
+        const condition = explicitCondition !== undefined && inheritedCondition !== undefined
+            ? createBinaryExpression("&&", inheritedCondition, explicitCondition)
+            : (explicitCondition ?? inheritedCondition);
+        const dependsOn = options?.dependsOn;
+        let data;
+        if (isExisting) {
+            // Existing arm: only name + optional scope land in state. Any other
+            // keys on the props object are ignored — the deserialize path may pass
+            // them through, but they're never emitted on an `existing` resource.
+            if (props.name === undefined) {
+                throw new Error(`Resource ${props.type} marked as 'existing' but no 'name' was provided.`);
+            }
+            data = {
+                name: props.name,
+                type: props.type,
+                apiVersion: props.apiVersion,
+                existing: true,
+                scope: props.scope === undefined ? undefined : unwrapExpression(props.scope),
+                condition,
+                dependsOn,
+            };
+            if (parentIndex !== undefined) {
+                data[STATE_PARENT_INDEX] = parentIndex;
+            }
+        }
+        else {
+            // Deployable arm: name flows through the naming policy; the keys
+            // handled explicitly here are stripped from the props bag, and
+            // every remaining key is copied verbatim into state as a user-
+            // authored property.
+            const { name: _name, type: _type, apiVersion: _apiVersion, existing: _existing, scope: _scope, ...userProps } = props;
+            const ctx = this.deploymentContext;
+            data = {
+                name: resolveResourceName(ctx.namingPolicy ?? namingRequiredPolicy, props.name, props.type, namingRules),
+                type: props.type,
+                apiVersion: props.apiVersion,
+                condition,
+                dependsOn,
+                ...userProps,
+            };
+            if (parentIndex !== undefined) {
+                data[STATE_PARENT_INDEX] = parentIndex;
+            }
+            // Apply DeploymentContext defaults for `location` and `tags`, gated
+            // on the shape descriptor declaring those properties as writable.
+            // The TypeSpec model is the source of truth: a field marked
+            // readonly in the ARM contract (e.g. `location` on most child
+            // resources) is server-set, so propagating an inherited value
+            // would produce an invalid PUT body. Both fields are user-wins:
+            // if the user supplied a value, the inherited value is ignored
+            // entirely (no merge for tags either — explicit user tags fully
+            // replace inherited tags).
+            const shape = getShape(props.type, props.apiVersion, data);
+            if (shape !== undefined) {
+                const locationShape = shape.byJsName["location"];
+                if (locationShape !== undefined &&
+                    locationShape.readOnly !== true &&
+                    data["location"] === undefined &&
+                    ctx.location !== undefined) {
+                    data["location"] = ctx.location;
+                }
+                const tagsShape = shape.byJsName["tags"];
+                if (tagsShape !== undefined &&
+                    tagsShape.readOnly !== true &&
+                    data["tags"] === undefined &&
+                    ctx.tags !== undefined &&
+                    Object.keys(ctx.tags).length > 0) {
+                    data["tags"] = { ...ctx.tags };
+                }
+            }
+        }
+        this.state = data;
+    }
+    /**
+     * Core-internal escape hatch: exposes the raw `state` backing object to
+     * the proxy layer (`resource-proxy.ts`) so it can read/unwrap the
+     * declaration's data across module boundaries. Keyed by the
+     * module-scoped {@link RAW_RESOURCE_HANDLE} symbol, which is **not**
+     * exported from `@azure/provisioning-core`, so package consumers can't name it.
+     *
+     * `protected` (not `private`) because the accessors that read it use
+     * `Reflect.get` / structural casts that bypass TS visibility anyway;
+     * the modifier just keeps it off the public type surface. It can't be a
+     * `#private` field because the proxy layer lives in a different class.
+     *
+     * @internal
+     */
+    get [RAW_RESOURCE_HANDLE]() {
+        return this.state;
+    }
+    get type() {
+        return this.state.type;
+    }
+    get apiVersion() {
+        return this.state.apiVersion;
+    }
+    get existing() {
+        return this.state.existing;
+    }
+    get condition() {
+        return this.state.condition;
+    }
+    get dependsOn() {
+        return this.state.dependsOn;
+    }
+    expr(...path) {
+        return createResourceMemberProxy({
+            resource: this,
+            root: unwrapResourceHandle(this),
+        }, path);
+    }
+    setProperty(key, value) {
+        this.state[key] = normalizeAssignedValue(value, this);
+    }
+}
+/**
+ * Base class for all Azure resources.
+ *
+ * @remarks
+ * Resources are fully initialized at construction time. Pass a parent
+ * `ProvisioningComponent` (typically a `Stack` or `ResourceGroup`) as the first
+ * argument — the resource registers itself in the tree automatically.
+ *
+ * Properties use expression-backed proxies: reading `resource.name`
+ * returns an `Expression` that compiles to a Bicep symbolic reference,
+ * not a plain string. Use `this.expr()` in subclasses to create
+ * property getters and `this.setProperty()` for setters.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { ResourceGroup, Stack } from "@azure/provisioning-core";
+ * import { KeyVault } from "@azure/provisioning-keyvault";
+ *
+ * const stack = new Stack("my-app", { targetScope: "subscription" });
+ * const rg = new ResourceGroup(stack, { name: "rg-my-app", location: "eastus" });
+ * const vault = new KeyVault(rg, {
+ *   name: "kv-my-app",
+ *   properties: {
+ *     tenantId: "11111111-1111-1111-1111-111111111111",
+ *     sku: { family: "A", name: "standard" },
+ *   },
+ * });
+ *
+ * // vault.name is an Expression, not a string
+ * // vault.id compiles to resourceId(...)
+ * ```
+ */
+export class Resource extends ResourceDeclaration {
+    /**
+     * Brand marker for cross-realm `isResource()` checks.
+     * Uses `Symbol.for` so it survives multiple copies of `@azure/provisioning-core`.
+     */
+    [RESOURCE_BRAND] = true;
+    /**
+     * Register a {@link FlatModelShape} for this resource class's
+     * `(resourceType, apiVersion)` pair. Intended to be invoked from a
+     * `static {}` initializer in generated subclasses so the registration
+     * happens at module load.
+     *
+     * The static method reads `resourceType` and `apiVersion` off `this`
+     * (the subclass that called it), so callers don't repeat the literals.
+     */
+    static registerShape(shape, variantSelector) {
+        registerShapeInRegistry(this.resourceType, this.apiVersion, shape, variantSelector);
+    }
+    /**
+     * Register this class with the global resource registry so the
+     * deserializer can reconstruct instances of it (instead of falling
+     * back to base `Resource`) for matching `(resourceType, apiVersion)`
+     * pairs. Intended to be invoked from a `static {}` initializer in
+     * generated classes alongside {@link Resource.registerShape}.
+     *
+     * Pass an ordered discriminator path for concrete resource variants. A
+     * singleton is one segment (`name=signin`); model-discriminated resources
+     * may use `kind` or several nested segments. Omit for ordinary resources.
+     */
+    static register(variantSelector) {
+        registerResourceInRegistry(this, variantSelector);
+    }
+    /**
+     * Assemble the base-`Resource` constructor payload (the second `super(...)`
+     * argument) from the user-facing props. This is a **static "virtual"**:
+     * it runs before an instance exists (to compute the `super` argument), so
+     * it can't be an instance method — but it still dispatches through the
+     * calling constructor, so a subclass's override wins.
+     *
+     * Every emitter-generated resource overrides this to inject its fixed
+     * identity (`type` / `apiVersion`), the singleton `name`, and its explicit
+     * writable-field copy. Both ordinary construction and internal resource
+     * reconstruction funnel through this method so prop shaping remains
+     * consistent.
+     *
+     * This base default is the fallback used when the wrapped constructor is
+     * base `Resource` itself — the deserialize path for an unregistered
+     * `(type, apiVersion)` pair, where `type` / `apiVersion` are threaded in
+     * through `props` rather than read off statics. Keeping the default here
+     * guarantees the method is always present for internal reconstruction.
+     */
+    static buildResourceProps(props) {
+        const p = props ?? {};
+        return {
+            ...p,
+            type: p["type"] ??
+                this.resourceType,
+            apiVersion: p["apiVersion"] ??
+                this.apiVersion,
+        };
+    }
+    /**
+     * Per-resource-type naming constraints, consumed by the active
+     * {@link NamingPolicy} when a resource is created without an explicit
+     * `name`. Generated CDK subclasses override this with a concrete value;
+     * the base default of `undefined` yields `MOST_RESTRICTIVE` behavior.
+     *
+     * This is type metadata, not user input, so it is kept off the public
+     * props surface and read reflectively in the constructor via
+     * `this.constructor` rather than being threaded through `ResourceProps`.
+     */
+    static namingRules;
+    _selfProxy;
+    constructor(context, props, options) {
+        super(context, props, options, 
+        // Naming rules live as a `protected static namingRules` field on
+        // each concrete resource subclass, not on the public props bag.
+        // Read reflectively off `new.target` (the most-derived class being
+        // instantiated) — `this.constructor` would work too but TS forbids
+        // touching `this` before `super()`. Static inheritance falls back
+        // to `Resource`'s `undefined` default when a subclass omits the
+        // field (e.g. singleton children). `resolveResourceName` (called
+        // inside `ResourceDeclaration`) treats `undefined` as
+        // `MOST_RESTRICTIVE`.
+        new.target.namingRules);
+        const proxy = createResourceProxy(this);
+        this._selfProxy = proxy;
+        // Tricky part for the proxy implementation:
+        // ProvisioningComponent constructor pushed `this` (bare instance) into parent.children
+        // before the proxy existed. Swap it for the proxy so external consumers
+        // see proxy-backed handles (with property access, etc.) when iterating.
+        const idx = context.children.indexOf(this);
+        if (idx >= 0)
+            context.children[idx] = proxy;
+        return proxy;
+    }
+    get self() {
+        return this._selfProxy ?? this;
+    }
+    /**
+     * The Azure resource name as a Bicep symbolic-reference expression.
+     *
+     * The value is established at construction time (either user-supplied
+     * via `props.name` or filled in by the naming policy) and stored on
+     * `state.name`. The setter routes through `setProperty` so post-
+     * construction edits flow through the same proxy/expression machinery
+     * as any other property — useful when working with a base `Resource`
+     * reference and re-binding the name dynamically. Singleton subclasses
+     * override this getter to narrow the return type to the literal
+     * `Expression<"<singletonName>">`; non-singleton subclasses inherit
+     * this accessor pair as-is.
+     */
+    get name() {
+        return this.expr("name");
+    }
+    set name(value) {
+        this.setProperty("name", value);
+    }
+    get id() {
+        return this.expr("id");
+    }
+}
+/**
+ * Describes a Bicep `[for item in collection: ...]` loop as a plain data
+ * object. Construct one and pass it to
+ * `Ctor.fromLoop(loop, context, props, options?)` (e.g.
+ * `StorageAccount.fromLoop(...)`) to expand a resource declaration into a
+ * resource-copy loop.
+ *
+ * The item and index variable names default to `item` / `i`. Bicep
+ * for-expressions bind their loop variables only within their own body,
+ * so two sibling `[for item in xs: …]` / `[for item in ys: …]` in the
+ * same file do **not** collide — each `item` is scoped to its own
+ * expression. If you nest a `Loop` inside another loop's body (rare),
+ * pass `{ itemVariable, indexVariable }` explicitly on the inner one to
+ * disambiguate. `batchSize` on the loop renders as `@batchSize(n)` on
+ * the resource that consumes it.
+ *
+ * The `indexVariable` name is always materialized on read (never
+ * `undefined`), but whether the wire actually **records** it — and
+ * therefore whether the renderer emits the `[for (item, i) in …]` tuple
+ * binding — is decided by whether anyone accessed `loop.index` (or the
+ * caller supplied `{ indexVariable }` explicitly). A loop whose body
+ * never mentions an index emits a bare `[for item in xs: …]`.
+ *
+ * `Loop` instances are pure data — creating one has no side effect.
+ */
+export class Loop {
+    collection;
+    itemVariable;
+    item;
+    batchSize;
+    // The default name assigned to `indexVariable` on first materialization,
+    // if the caller neither passed `{ indexVariable }` nor accessed `.index`.
+    #defaultIndexVariable;
+    #indexVariable;
+    #indexExpr;
+    #indexRequested = false;
+    constructor(collection, options) {
+        this.collection = collection;
+        this.itemVariable = options?.itemVariable ?? "item";
+        this.#defaultIndexVariable = "i";
+        if (options?.indexVariable !== undefined) {
+            // Explicit option counts as a request — the wire and renderer must
+            // honor the caller's chosen name whether or not they read `.index`.
+            this.#indexVariable = options.indexVariable;
+            this.#indexRequested = true;
+        }
+        if (options?.batchSize !== undefined) {
+            this.batchSize = options.batchSize;
+        }
+        this.item = wrapExpression(symbolicValueExpressionNode(this.itemVariable));
+    }
+    /**
+     * Name of the loop's index variable. Always defined — reading it
+     * materializes the default (`i`) if the caller neither passed
+     * `{ indexVariable }` nor accessed `.index` yet.
+     *
+     * Reading `.indexVariable` also marks the index as requested (same as
+     * reading `.index`), because a caller who wants the variable name is
+     * almost certainly going to use it. If the wire-omit optimization
+     * (bare `[for item in …]` with no index binding) matters, callers
+     * should gate on `.indexRequested` first before touching this getter.
+     */
+    get indexVariable() {
+        this.#indexRequested = true;
+        if (this.#indexVariable === undefined) {
+            this.#indexVariable = this.#defaultIndexVariable;
+        }
+        return this.#indexVariable;
+    }
+    /**
+     * Expression referencing the current iteration's index. Reading this the
+     * first time marks the index as requested, which causes the wire to
+     * include `indexVariable` on the `for-expression` node and the renderer
+     * to emit `[for (item, i) in …]`. Callers who never touch `.index` get
+     * the cleaner index-less form.
+     */
+    get index() {
+        this.#indexRequested = true;
+        if (this.#indexExpr === undefined) {
+            const name = this.indexVariable;
+            this.#indexExpr = wrapExpression(symbolicValueExpressionNode(name));
+        }
+        return this.#indexExpr;
+    }
+    /**
+     * Framework-internal signal used by `Resource.fromLoop` to decide
+     * whether the wire should include the index binding. `true` when the
+     * caller either supplied `{ indexVariable }` explicitly or has accessed
+     * `.index` / `.indexVariable` at least once. Not exported from
+     * `@azure/provisioning-core`.
+     *
+     * @internal
+     */
+    get indexRequested() {
+        return this.#indexRequested;
+    }
+}
+// ---------------------------------------------------------------------------
+// LoopedResource<T> — a Bicep for-expanded resource declaration as a real
+// ProvisioningComponent in the tree, sitting alongside scalar `Resource` under the same
+// `ResourceDeclaration` base.
+// ---------------------------------------------------------------------------
+/**
+ * A `LoopedResource<T>` represents a single Bicep resource declaration
+ * expanded across a loop (`[for x in xs: {...}]`). It is a real
+ * `ProvisioningComponent` in the tree — one node per emitted declaration — and
+ * exposes indexed access into individual iterations via
+ * {@link LoopedResource.at}.
+ *
+ * @remarks
+ *
+ * Property access on a `LoopedResource` is deliberately not exposed at
+ * the type level: pick an index (`at`) to obtain a proxy that emits
+ * `sym[i].prop`. This mirrors Bicep's requirement that individual
+ * iterations be accessed by index.
+ *
+ * `.at(i)` returns the concrete resource type `T`. The returned proxy
+ * exposes the essential ARM surface — the property getters/setters that
+ * funnel through `this.expr(...)` (`.id`, `.name`, `.sku`,
+ * `.properties.*`, …) rooted at `sym[i]` — as well as the child
+ * accessors (`keyVault.secrets`, singleton getter/setters), which are
+ * derived from the parent's `children` scoped to element `i`. To attach
+ * per-iteration children, parent them to `parent.at(loop.index)` — e.g.
+ * `Child.fromLoop(loop, parent.at(loop.index), ...)`.
+ *
+ * Projection over the loop (Bicep `map(sym, x => body)`) is tracked as
+ * a follow-up effort — see the "lambda + fn.map" issue.
+ */
+export class LoopedResource extends ResourceDeclaration {
+    /**
+     * Cross-realm brand — same technique as the scalar `RESOURCE_BRAND`.
+     * Use {@link isLoopedResource} instead of `instanceof`
+     * when multiple copies of `@azure/provisioning-core` may be loaded.
+     */
+    [LOOPED_RESOURCE_BRAND] = true;
+    /** Metadata describing the loop that produced this declaration. */
+    loop;
+    #wrappedCtor;
+    constructor(context, wrappedCtor, userProps, loop, options) {
+        // The subclass constructor never runs for a looped row — only this
+        // shared `ResourceDeclaration` ctor does. To keep the scalar and
+        // looped construction paths from drifting, shape the props bag through
+        // the SAME static the scalar ctor uses: every `Resource` (sub)class
+        // inherits or overrides `buildResourceProps`, which returns the exact
+        // `super()` payload the scalar ctor passes — including the fixed `name`
+        // for singletons and any other prop shaping. (This is what fixes looped
+        // singletons losing their fixed `name`.)
+        //
+        // It is always present: base `Resource` — the deserialize fallback ctor
+        // for an unregistered `(type, apiVersion)` pair — supplies a default
+        // that threads `type` / `apiVersion` in from `userProps`. So there's no
+        // existence branch here.
+        const props = wrappedCtor.buildResourceProps.call(wrappedCtor, userProps);
+        super(context, props, options, wrappedCtor.namingRules);
+        this.#wrappedCtor = wrappedCtor;
+        // Snapshot the loop metadata at declaration time. `indexVariable` is
+        // recorded only if the index was requested by now — either the caller
+        // supplied `{ indexVariable }` or read `loop.index` / `loop.indexVariable`
+        // before this declaration. Reading `loop.index` (e.g. via
+        // `parent.at(loop.index)`) marks the live loop so descendant
+        // declarations (which snapshot the same loop afterwards) pick up the
+        // binding, while this declaration's own for-expression stays index-less.
+        this.loop = {
+            collection: loop.collection,
+            itemVariable: loop.itemVariable,
+            ...(loop.indexRequested ? { indexVariable: loop.indexVariable } : {}),
+            ...(loop.batchSize !== undefined ? { batchSize: loop.batchSize } : {}),
+        };
+    }
+    /**
+     * The concrete `Resource` subclass this looped declaration wraps.
+     * Used by query machinery to answer "which subclass is this looped
+     * resource" — the analogue of `instanceof T` for `LoopedResource<T>`.
+     *
+     * This is always the full subclass the user constructed via
+     * `Xxx.fromLoop(...)` — query identity matches on that class, and it is
+     * the prototype the `.at(i)` proxy uses to resolve ARM accessors.
+     */
+    get wrappedCtor() {
+        return this.#wrappedCtor;
+    }
+    /**
+     * Reference the element at `index`. Emits `sym[index].<...>` for
+     * subsequent property access.
+     *
+     * Returns the concrete resource type `T`. At runtime an indexed proxy is
+     * spliced over the full class prototype (`#wrappedCtor.prototype`):
+     * prototype getters that funnel through `this.expr(...)` (`.id`, `.name`,
+     * `.properties.*`, …) resolve rooted at `sym[index]`. A child created with
+     * `parent.at(i)` is stamped with that index for serialization.
+     */
+    at(index) {
+        // `this` is a `ResourceDeclaration`; the handle derives the subclass
+        // prototype from `this.wrappedCtor`. The explicit type argument pins
+        // the return type, which TypeScript can't otherwise resolve from the
+        // deferred polymorphic `this`.
+        return createIndexedResourceProxy(this, index);
+    }
+}
+/** @internal */
+export function createLoopedResource(wrappedCtor, loop, context, ...rest) {
+    const [userProps, options] = rest;
+    // `LoopedResource`'s ctor is private; access via cast because this module
+    // owns both the declaration and its internal construction boundary.
+    const LoopedCtor = LoopedResource;
+    return new LoopedCtor(context, wrappedCtor, userProps, loop, options);
+}
+//# sourceMappingURL=resource.js.map