@azure/provisioning-core 1.0.0-beta.1

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

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

package/dist/esm/constructs/stack.d.ts

@@ -0,0 +1,110 @@
+import { ProvisioningComponent } from "./provisioning-component.js";
+import type { ExpressionOrValue } from "../expression/expressions.js";
+import type { NamingPolicy } from "../naming/naming-policy.js";
+import { OutputCollection } from "./output.js";
+import { ParameterCollection } from "./parameter.js";
+import { VariableCollection } from "./variable.js";
+import { type QueryOptions } from "./resource/resource-query.js";
+import { type Loop, type LoopedResource, type Resource, type ResourceOptions } from "./resource/resource.js";
+import type { ResourceCtor } from "./resource/resource-registry.js";
+import type { TargetScope } from "../serialization/contract/index.js";
+export interface StackOptions {
+    readonly targetScope?: TargetScope | undefined;
+    readonly location?: ExpressionOrValue<string> | undefined;
+    readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;
+    readonly namingPolicy?: NamingPolicy | undefined;
+}
+/**
+ * A Stack defines a deployment unit.
+ *
+ * @remarks
+ * Each stack produces one or more Bicep files — resources at different
+ * scopes (subscription vs. resource group) are split into separate files
+ * linked by module references.
+ *
+ * Resources register themselves by passing the stack (or a child component)
+ * as their first constructor argument. `Stack.add()` is available as a
+ * convenience for creating child components with the stack as parent.
+ *
+ * The `targetScope` option controls the Bicep target scope. Default is
+ * `"subscription"`, which requires explicit `ResourceGroup` instances.
+ * Set `"resourceGroup"` to deploy resources directly into an existing
+ * resource group.
+ *
+ * Every stack registers itself in `Stack.roots` for collection by tools
+ * like the playground and CLI.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, ResourceGroup } from "@azure/provisioning-core";
+ * import { KeyVault } from "@azure/provisioning-keyvault";
+ *
+ * const stack = new Stack("my-app");
+ * 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" },
+ *   },
+ * });
+ * ```
+ */
+export declare class Stack extends ProvisioningComponent {
+    #private;
+    readonly name: string;
+    readonly targetScope: TargetScope;
+    readonly parameters: ParameterCollection;
+    readonly variables: VariableCollection;
+    readonly outputs: OutputCollection;
+    /** All root stacks created since the last call to `Stack.clearRoots()`. */
+    static get roots(): readonly Stack[];
+    /**
+     * Returns all root stacks and clears the registry. Useful for collecting
+     * all stacks after executing user code (e.g. in the playground or CLI).
+     */
+    static clearRoots(): Stack[];
+    /** Create a root stack. */
+    constructor(name: string, options?: StackOptions);
+    /**
+     * The scalar resources in this stack. With no `type`, returns
+     * every scalar resource; pass a resource class to filter and narrow to
+     * that subclass. Returns a plain array — use native `.filter` / `.find` /
+     * `.map` for anything further.
+     *
+     * By default walks the whole tree; pass `{ recursive: false }` to consider
+     * only the stack's direct children.
+     */
+    getResources(options?: QueryOptions): Resource[];
+    getResources<T extends Resource>(type: ResourceCtor<T>, options?: QueryOptions): T[];
+    /**
+     * Find the **first** scalar resource of `type` whose literal name equals
+     * `name`, or `undefined` if none matches.
+     *
+     * @remarks
+     * Returns the first match in tree order. ARM names are unique only *per
+     * resource type within a scope*, so a stack MAY legitimately contain more
+     * than one resource of the same `type` and `name` (e.g. across different
+     * resource groups) — this returns whichever is found first. Use
+     * `getResources(type)` and filter yourself if you need all matches.
+     *
+     * Only scalar resources are searched, and names that do not resolve to a
+     * string literal are never matched. Pass `{ recursive: false }` to search
+     * only the stack's direct children.
+     */
+    getResource<T extends Resource>(type: ResourceCtor<T>, name: string, options?: QueryOptions): T | undefined;
+    /**
+     * Create a child under this stack (with the stack as its parent context),
+     * as a convenience for `new Ctor(stack, ...args)`.
+     *
+     * Constructs a single child instance and returns it.
+     */
+    add<T extends new (context: ProvisioningComponent, ...args: any[]) => ProvisioningComponent>(ctor: T, ...args: ConstructorParameters<T> extends [any, ...infer Rest] ? Rest : never): InstanceType<T>;
+}
+/** @internal */
+export declare function getLoopedResources(stack: Stack, options?: QueryOptions): LoopedResource<Resource>[];
+/** @internal */
+export declare function getLoopedResources<T extends Resource>(stack: Stack, type: ResourceCtor<T>, options?: QueryOptions): LoopedResource<T>[];
+/** @internal */
+export declare function addLoopedResource<T extends Resource, P>(stack: Stack, ctor: new (context: Stack, props: P, options?: ResourceOptions) => T, loop: Loop<unknown>, ...rest: undefined extends P ? [props?: P, options?: ResourceOptions] : [props: P, options?: ResourceOptions]): LoopedResource<T>;
+//# sourceMappingURL=stack.d.ts.map

package/dist/esm/constructs/stack.d.ts.map

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

package/dist/esm/constructs/stack.js

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { ProvisioningComponent } from "./provisioning-component.js";
+import { DefaultNamingPolicy } from "../naming/naming-policy.js";
+import { OutputCollection } from "./output.js";
+import { ParameterCollection } from "./parameter.js";
+import { VariableCollection } from "./variable.js";
+import { getLoopedResources as runGetLoopedResources, getResources as runGetResources, getResource as runGetResource, } from "./resource/resource-query.js";
+import { createLoopedResource, } from "./resource/resource.js";
+/**
+ * A Stack defines a deployment unit.
+ *
+ * @remarks
+ * Each stack produces one or more Bicep files — resources at different
+ * scopes (subscription vs. resource group) are split into separate files
+ * linked by module references.
+ *
+ * Resources register themselves by passing the stack (or a child component)
+ * as their first constructor argument. `Stack.add()` is available as a
+ * convenience for creating child components with the stack as parent.
+ *
+ * The `targetScope` option controls the Bicep target scope. Default is
+ * `"subscription"`, which requires explicit `ResourceGroup` instances.
+ * Set `"resourceGroup"` to deploy resources directly into an existing
+ * resource group.
+ *
+ * Every stack registers itself in `Stack.roots` for collection by tools
+ * like the playground and CLI.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, ResourceGroup } from "@azure/provisioning-core";
+ * import { KeyVault } from "@azure/provisioning-keyvault";
+ *
+ * const stack = new Stack("my-app");
+ * 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" },
+ *   },
+ * });
+ * ```
+ */
+export class Stack extends ProvisioningComponent {
+    name;
+    targetScope;
+    parameters = new ParameterCollection();
+    variables = new VariableCollection();
+    outputs = new OutputCollection();
+    // --- Static root stack registry ---
+    static #roots = [];
+    /** All root stacks created since the last call to `Stack.clearRoots()`. */
+    static get roots() {
+        return Stack.#roots;
+    }
+    /**
+     * Returns all root stacks and clears the registry. Useful for collecting
+     * all stacks after executing user code (e.g. in the playground or CLI).
+     */
+    static clearRoots() {
+        return Stack.#roots.splice(0, Stack.#roots.length);
+    }
+    /** Create a root stack. */
+    constructor(name, options) {
+        super();
+        const opts = options ?? {};
+        this.name = name;
+        this.targetScope = opts.targetScope ?? "subscription";
+        Stack.#roots.push(this);
+        this._localDeploymentContext = {
+            location: opts.location,
+            tags: opts.tags,
+            namingPolicy: opts.namingPolicy ?? new DefaultNamingPolicy({ workload: name }),
+        };
+    }
+    getResources(typeOrOptions, maybeOptions) {
+        return runGetResources(this, typeOrOptions, maybeOptions);
+    }
+    /**
+     * Find the **first** scalar resource of `type` whose literal name equals
+     * `name`, or `undefined` if none matches.
+     *
+     * @remarks
+     * Returns the first match in tree order. ARM names are unique only *per
+     * resource type within a scope*, so a stack MAY legitimately contain more
+     * than one resource of the same `type` and `name` (e.g. across different
+     * resource groups) — this returns whichever is found first. Use
+     * `getResources(type)` and filter yourself if you need all matches.
+     *
+     * Only scalar resources are searched, and names that do not resolve to a
+     * string literal are never matched. Pass `{ recursive: false }` to search
+     * only the stack's direct children.
+     */
+    getResource(type, name, options) {
+        return runGetResource(this, type, name, options);
+    }
+    add(ctor, ...rest) {
+        return new ctor(this.self, ...rest);
+    }
+}
+export function getLoopedResources(stack, typeOrOptions, maybeOptions) {
+    return runGetLoopedResources(stack, typeOrOptions, maybeOptions);
+}
+/** @internal */
+export function addLoopedResource(stack, ctor, loop, ...rest) {
+    return createLoopedResource(ctor, loop, stack.self, ...rest);
+}
+//# sourceMappingURL=stack.js.map

package/dist/esm/constructs/stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.js","sourceRoot":"","sources":["../../../src/constructs/stack.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EACL,kBAAkB,IAAI,qBAAqB,EAC3C,YAAY,IAAI,eAAe,EAC/B,WAAW,IAAI,cAAc,GAE9B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,oBAAoB,GAKrB,MAAM,wBAAwB,CAAC;AAehC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,OAAO,KAAM,SAAQ,qBAAqB;IACrC,IAAI,CAAS;IACb,WAAW,CAAc;IACzB,UAAU,GAAwB,IAAI,mBAAmB,EAAE,CAAC;IAC5D,SAAS,GAAuB,IAAI,kBAAkB,EAAE,CAAC;IACzD,OAAO,GAAqB,IAAI,gBAAgB,EAAE,CAAC;IAE5D,qCAAqC;IAErC,MAAM,CAAC,MAAM,GAAY,EAAE,CAAC;IAE5B,2EAA2E;IAC3E,MAAM,KAAK,KAAK;QACd,OAAO,KAAK,CAAC,MAAM,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU;QACf,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;IAED,2BAA2B;IAC3B,YAAY,IAAY,EAAE,OAAsB;QAC9C,KAAK,EAAE,CAAC;QACR,MAAM,IAAI,GAAG,OAAO,IAAI,EAAE,CAAC;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,cAAc,CAAC;QACtD,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,uBAAuB,GAAG;YAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,IAAI,mBAAmB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;SAC/E,CAAC;IACJ,CAAC;IAoBD,YAAY,CACV,aAAqD,EACrD,YAA2B;QAE3B,OAAO,eAAe,CAAC,IAAI,EAAE,aAAsB,EAAE,YAAY,CAAC,CAAC;IACrE,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,WAAW,CACT,IAAqB,EACrB,IAAY,EACZ,OAAsB;QAEtB,OAAO,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IAYD,GAAG,CACD,IAAmF,EACnF,GAAG,IAAW;QAEd,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;IACtC,CAAC;;AAcH,MAAM,UAAU,kBAAkB,CAChC,KAAY,EACZ,aAAqD,EACrD,YAA2B;IAE3B,OAAO,qBAAqB,CAAC,KAAK,EAAE,aAAsB,EAAE,YAAY,CAAC,CAAC;AAC5E,CAAC;AAED,gBAAgB;AAChB,MAAM,UAAU,iBAAiB,CAC/B,KAAY,EACZ,IAAoE,EACpE,IAAmB,EACnB,GAAG,IAEsC;IAEzC,OAAO,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC;AAC/D,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { ProvisioningComponent } from \"./provisioning-component.js\";\nimport type { ExpressionOrValue } from \"../expression/expressions.js\";\nimport type { NamingPolicy } from \"../naming/naming-policy.js\";\nimport { DefaultNamingPolicy } from \"../naming/naming-policy.js\";\nimport { OutputCollection } from \"./output.js\";\nimport { ParameterCollection } from \"./parameter.js\";\nimport { VariableCollection } from \"./variable.js\";\nimport {\n  getLoopedResources as runGetLoopedResources,\n  getResources as runGetResources,\n  getResource as runGetResource,\n  type QueryOptions,\n} from \"./resource/resource-query.js\";\nimport {\n  createLoopedResource,\n  type Loop,\n  type LoopedResource,\n  type Resource,\n  type ResourceOptions,\n} from \"./resource/resource.js\";\nimport type { ResourceCtor } from \"./resource/resource-registry.js\";\nimport type { TargetScope } from \"../serialization/contract/index.js\";\n\n// ---------------------------------------------------------------------------\n// Stack — class-based API for creating stacks\n// ---------------------------------------------------------------------------\n\nexport interface StackOptions {\n  readonly targetScope?: TargetScope | undefined;\n  readonly location?: ExpressionOrValue<string> | undefined;\n  readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;\n  readonly namingPolicy?: NamingPolicy | undefined;\n}\n\n/**\n * A Stack defines a deployment unit.\n *\n * @remarks\n * Each stack produces one or more Bicep files — resources at different\n * scopes (subscription vs. resource group) are split into separate files\n * linked by module references.\n *\n * Resources register themselves by passing the stack (or a child component)\n * as their first constructor argument. `Stack.add()` is available as a\n * convenience for creating child components with the stack as parent.\n *\n * The `targetScope` option controls the Bicep target scope. Default is\n * `\"subscription\"`, which requires explicit `ResourceGroup` instances.\n * Set `\"resourceGroup\"` to deploy resources directly into an existing\n * resource group.\n *\n * Every stack registers itself in `Stack.roots` for collection by tools\n * like the playground and CLI.\n *\n * @example\n * ```typescript snippet:ignore\n * import { Stack, ResourceGroup } from \"@azure/provisioning-core\";\n * import { KeyVault } from \"@azure/provisioning-keyvault\";\n *\n * const stack = new Stack(\"my-app\");\n * const rg = new ResourceGroup(stack, { name: \"rg-my-app\", location: \"eastus\" });\n * const vault = new KeyVault(rg, {\n *   name: \"kv-my-app\",\n *   properties: {\n *     tenantId: \"11111111-1111-1111-1111-111111111111\",\n *     sku: { family: \"A\", name: \"standard\" },\n *   },\n * });\n * ```\n */\nexport class Stack extends ProvisioningComponent {\n  readonly name: string;\n  readonly targetScope: TargetScope;\n  readonly parameters: ParameterCollection = new ParameterCollection();\n  readonly variables: VariableCollection = new VariableCollection();\n  readonly outputs: OutputCollection = new OutputCollection();\n\n  // --- Static root stack registry ---\n\n  static #roots: Stack[] = [];\n\n  /** All root stacks created since the last call to `Stack.clearRoots()`. */\n  static get roots(): readonly Stack[] {\n    return Stack.#roots;\n  }\n\n  /**\n   * Returns all root stacks and clears the registry. Useful for collecting\n   * all stacks after executing user code (e.g. in the playground or CLI).\n   */\n  static clearRoots(): Stack[] {\n    return Stack.#roots.splice(0, Stack.#roots.length);\n  }\n\n  /** Create a root stack. */\n  constructor(name: string, options?: StackOptions) {\n    super();\n    const opts = options ?? {};\n    this.name = name;\n    this.targetScope = opts.targetScope ?? \"subscription\";\n    Stack.#roots.push(this);\n    this._localDeploymentContext = {\n      location: opts.location,\n      tags: opts.tags,\n      namingPolicy: opts.namingPolicy ?? new DefaultNamingPolicy({ workload: name }),\n    };\n  }\n\n  // --- Query ---\n  // Query the resources in this stack. Exposed on `Stack` (not `ProvisioningComponent`)\n  // because \"all resources in the stack\" is unambiguous, whereas\n  // `resource.getResources()` — which excludes the resource itself —\n  // would be confusing. For multiple stacks, use\n  // `stacks.flatMap(s => s.getResources(...))`.\n\n  /**\n   * The scalar resources in this stack. With no `type`, returns\n   * every scalar resource; pass a resource class to filter and narrow to\n   * that subclass. Returns a plain array — use native `.filter` / `.find` /\n   * `.map` for anything further.\n   *\n   * By default walks the whole tree; pass `{ recursive: false }` to consider\n   * only the stack's direct children.\n   */\n  getResources(options?: QueryOptions): Resource[];\n  getResources<T extends Resource>(type: ResourceCtor<T>, options?: QueryOptions): T[];\n  getResources(\n    typeOrOptions?: ResourceCtor<Resource> | QueryOptions,\n    maybeOptions?: QueryOptions,\n  ): Resource[] {\n    return runGetResources(this, typeOrOptions as never, maybeOptions);\n  }\n\n  /**\n   * Find the **first** scalar resource of `type` whose literal name equals\n   * `name`, or `undefined` if none matches.\n   *\n   * @remarks\n   * Returns the first match in tree order. ARM names are unique only *per\n   * resource type within a scope*, so a stack MAY legitimately contain more\n   * than one resource of the same `type` and `name` (e.g. across different\n   * resource groups) — this returns whichever is found first. Use\n   * `getResources(type)` and filter yourself if you need all matches.\n   *\n   * Only scalar resources are searched, and names that do not resolve to a\n   * string literal are never matched. Pass `{ recursive: false }` to search\n   * only the stack's direct children.\n   */\n  getResource<T extends Resource>(\n    type: ResourceCtor<T>,\n    name: string,\n    options?: QueryOptions,\n  ): T | undefined {\n    return runGetResource(this, type, name, options);\n  }\n\n  /**\n   * Create a child under this stack (with the stack as its parent context),\n   * as a convenience for `new Ctor(stack, ...args)`.\n   *\n   * Constructs a single child instance and returns it.\n   */\n  add<T extends new (context: ProvisioningComponent, ...args: any[]) => ProvisioningComponent>(\n    ctor: T,\n    ...args: ConstructorParameters<T> extends [any, ...infer Rest] ? Rest : never\n  ): InstanceType<T>;\n  add(\n    ctor: new (context: ProvisioningComponent, ...args: any[]) => ProvisioningComponent,\n    ...rest: any[]\n  ): ProvisioningComponent {\n    return new ctor(this.self, ...rest);\n  }\n}\n\n/** @internal */\nexport function getLoopedResources(\n  stack: Stack,\n  options?: QueryOptions,\n): LoopedResource<Resource>[];\n/** @internal */\nexport function getLoopedResources<T extends Resource>(\n  stack: Stack,\n  type: ResourceCtor<T>,\n  options?: QueryOptions,\n): LoopedResource<T>[];\nexport function getLoopedResources(\n  stack: Stack,\n  typeOrOptions?: ResourceCtor<Resource> | QueryOptions,\n  maybeOptions?: QueryOptions,\n): LoopedResource<Resource>[] {\n  return runGetLoopedResources(stack, typeOrOptions as never, maybeOptions);\n}\n\n/** @internal */\nexport function addLoopedResource<T extends Resource, P>(\n  stack: Stack,\n  ctor: new (context: Stack, props: P, options?: ResourceOptions) => T,\n  loop: Loop<unknown>,\n  ...rest: undefined extends P\n    ? [props?: P, options?: ResourceOptions]\n    : [props: P, options?: ResourceOptions]\n): LoopedResource<T> {\n  return createLoopedResource(ctor, loop, stack.self, ...rest);\n}\n"]}

package/dist/esm/constructs/variable.d.ts

@@ -0,0 +1,63 @@
+import type { Expression, InputOf } from "../expression/expressions.js";
+import type { Stack } from "./stack.js";
+export type ExpressionValue<T> = T extends Expression<infer U> ? U : T;
+/**
+ * A value accepted as a deployment variable's value: any JSON literal
+ * (scalar, `null`, array, object — recursively), an `Expression`, or a
+ * resource view (`InputOf<unknown>`). The literal members are required so
+ * plain object/array literals are accepted (a bare `InputOf<unknown>` is a
+ * weak type and would reject them).
+ */
+export type VariableValue = string | number | boolean | null | readonly VariableValue[] | {
+    readonly [key: string]: VariableValue;
+} | InputOf<unknown>;
+export type VariableOptions = {
+    readonly description?: string | undefined;
+    readonly export?: boolean | undefined;
+};
+/**
+ * Pure declaration data for a deployment variable. Stored on the stack
+ * (paired with the returned expression handle in {@link VariableEntry});
+ * read by the serializer at emit time. Not part of the value-level handle.
+ */
+export interface VariableMetadata extends VariableOptions {
+    readonly name: string;
+    readonly value: VariableValue;
+}
+export type Variable<TValue extends VariableValue = VariableValue> = Expression<ExpressionValue<TValue>>;
+/**
+ * Authoring-time collection of a stack's deployment variables. Backed by an
+ * ordered private array; supports add/get/delete/iteration. Look variables up
+ * by name via {@link VariableCollection.get}.
+ */
+export declare class VariableCollection {
+    #private;
+    /** Add a variable; returns its expression handle. Throws on duplicate name. */
+    add<TValue extends VariableValue = VariableValue>(name: string, value: TValue, options?: VariableOptions): Variable<TValue>;
+    /** The expression handle for a variable, or `undefined`. */
+    get(name: string): Variable | undefined;
+    /** The declaration metadata for a variable, or `undefined`. */
+    getMetadata(name: string): VariableMetadata | undefined;
+    /** All variable handles, in insertion order. */
+    list(): readonly Variable[];
+    /** All declaration metadata, in insertion order. */
+    listMetadata(): readonly VariableMetadata[];
+    has(name: string): boolean;
+    /** Remove a variable by name. Returns whether one was removed. */
+    delete(name: string): boolean;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<Variable>;
+}
+/**
+ * A computed value evaluated at deploy time, compiled to a Bicep `var` declaration.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, createVariable } from "@azure/provisioning-core";
+ *
+ * const stack = new Stack("my-app");
+ * const suffix = createVariable(stack, "suffix", "prod");
+ * ```
+ */
+export declare function createVariable<TValue extends VariableValue = VariableValue>(stack: Stack, name: string, value: TValue, options?: VariableOptions): Variable<TValue>;
+//# sourceMappingURL=variable.d.ts.map

package/dist/esm/constructs/variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable.d.ts","sourceRoot":"","sources":["../../../src/constructs/variable.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAGxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,aAAa,EAAE,GACxB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;CAAE,GACzC,OAAO,CAAC,OAAO,CAAC,CAAC;AAErB,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACvC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AAOD,MAAM,MAAM,QAAQ,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,IAAI,UAAU,CAC7E,eAAe,CAAC,MAAM,CAAC,CACxB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,kBAAkB;;IAG7B,+EAA+E;IAC/E,GAAG,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,EAC9C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAAC,MAAM,CAAC;IAYnB,4DAA4D;IAC5D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAIvC,+DAA+D;IAC/D,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAIvD,gDAAgD;IAChD,IAAI,IAAI,SAAS,QAAQ,EAAE;IAI3B,oDAAoD;IACpD,YAAY,IAAI,SAAS,gBAAgB,EAAE;IAI3C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,kEAAkE;IAClE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAO7B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,QAAQ,CAAC;CAOhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,EACzE,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAAC,MAAM,CAAC,CAElB"}

package/dist/esm/constructs/variable.js

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { wrapExpression } from "../expression/expressions.js";
+import { symbolicValueExpressionNode } from "../expression/ast-nodes.js";
+import { assertBicepIdentifier } from "../util.js";
+/**
+ * Authoring-time collection of a stack's deployment variables. Backed by an
+ * ordered private array; supports add/get/delete/iteration. Look variables up
+ * by name via {@link VariableCollection.get}.
+ */
+export class VariableCollection {
+    #entries = [];
+    /** Add a variable; returns its expression handle. Throws on duplicate name. */
+    add(name, value, options) {
+        assertBicepIdentifier(name, "Deployment variable");
+        if (this.has(name)) {
+            throw new Error(`Duplicate deployment variable name: ${name}`);
+        }
+        const variable = wrapExpression(symbolicValueExpressionNode(name));
+        this.#entries.push({ metadata: { name, value, ...options }, variable });
+        return variable;
+    }
+    /** The expression handle for a variable, or `undefined`. */
+    get(name) {
+        return this.#find(name)?.variable;
+    }
+    /** The declaration metadata for a variable, or `undefined`. */
+    getMetadata(name) {
+        return this.#find(name)?.metadata;
+    }
+    /** All variable handles, in insertion order. */
+    list() {
+        return this.#entries.map((e) => e.variable);
+    }
+    /** All declaration metadata, in insertion order. */
+    listMetadata() {
+        return this.#entries.map((e) => e.metadata);
+    }
+    has(name) {
+        return this.#find(name) !== undefined;
+    }
+    /** Remove a variable by name. Returns whether one was removed. */
+    delete(name) {
+        const i = this.#entries.findIndex((e) => e.metadata.name === name);
+        if (i === -1)
+            return false;
+        this.#entries.splice(i, 1);
+        return true;
+    }
+    get size() {
+        return this.#entries.length;
+    }
+    [Symbol.iterator]() {
+        return this.#entries.map((e) => e.variable)[Symbol.iterator]();
+    }
+    #find(name) {
+        return this.#entries.find((e) => e.metadata.name === name);
+    }
+}
+/**
+ * A computed value evaluated at deploy time, compiled to a Bicep `var` declaration.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, createVariable } from "@azure/provisioning-core";
+ *
+ * const stack = new Stack("my-app");
+ * const suffix = createVariable(stack, "suffix", "prod");
+ * ```
+ */
+export function createVariable(stack, name, value, options) {
+    return stack.variables.add(name, value, options);
+}
+//# sourceMappingURL=variable.js.map

package/dist/esm/constructs/variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable.js","sourceRoot":"","sources":["../../../src/constructs/variable.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { Expression, InputOf } from \"../expression/expressions.js\";\nimport { wrapExpression } from \"../expression/expressions.js\";\nimport { symbolicValueExpressionNode } from \"../expression/ast-nodes.js\";\nimport type { Stack } from \"./stack.js\";\nimport { assertBicepIdentifier } from \"../util.js\";\n\nexport type ExpressionValue<T> = T extends Expression<infer U> ? U : T;\n\n/**\n * A value accepted as a deployment variable's value: any JSON literal\n * (scalar, `null`, array, object — recursively), an `Expression`, or a\n * resource view (`InputOf<unknown>`). The literal members are required so\n * plain object/array literals are accepted (a bare `InputOf<unknown>` is a\n * weak type and would reject them).\n */\nexport type VariableValue =\n  | string\n  | number\n  | boolean\n  | null\n  | readonly VariableValue[]\n  | { readonly [key: string]: VariableValue }\n  | InputOf<unknown>;\n\nexport type VariableOptions = {\n  readonly description?: string | undefined;\n  readonly export?: boolean | undefined;\n};\n\n/**\n * Pure declaration data for a deployment variable. Stored on the stack\n * (paired with the returned expression handle in {@link VariableEntry});\n * read by the serializer at emit time. Not part of the value-level handle.\n */\nexport interface VariableMetadata extends VariableOptions {\n  readonly name: string;\n  readonly value: VariableValue;\n}\n\ninterface VariableEntry {\n  readonly metadata: VariableMetadata;\n  readonly variable: Expression<unknown>;\n}\n\nexport type Variable<TValue extends VariableValue = VariableValue> = Expression<\n  ExpressionValue<TValue>\n>;\n\n/**\n * Authoring-time collection of a stack's deployment variables. Backed by an\n * ordered private array; supports add/get/delete/iteration. Look variables up\n * by name via {@link VariableCollection.get}.\n */\nexport class VariableCollection {\n  #entries: VariableEntry[] = [];\n\n  /** Add a variable; returns its expression handle. Throws on duplicate name. */\n  add<TValue extends VariableValue = VariableValue>(\n    name: string,\n    value: TValue,\n    options?: VariableOptions,\n  ): Variable<TValue> {\n    assertBicepIdentifier(name, \"Deployment variable\");\n    if (this.has(name)) {\n      throw new Error(`Duplicate deployment variable name: ${name}`);\n    }\n    const variable = wrapExpression<ExpressionValue<TValue>>(\n      symbolicValueExpressionNode<ExpressionValue<TValue>, string>(name),\n    );\n    this.#entries.push({ metadata: { name, value, ...options }, variable });\n    return variable;\n  }\n\n  /** The expression handle for a variable, or `undefined`. */\n  get(name: string): Variable | undefined {\n    return this.#find(name)?.variable;\n  }\n\n  /** The declaration metadata for a variable, or `undefined`. */\n  getMetadata(name: string): VariableMetadata | undefined {\n    return this.#find(name)?.metadata;\n  }\n\n  /** All variable handles, in insertion order. */\n  list(): readonly Variable[] {\n    return this.#entries.map((e) => e.variable);\n  }\n\n  /** All declaration metadata, in insertion order. */\n  listMetadata(): readonly VariableMetadata[] {\n    return this.#entries.map((e) => e.metadata);\n  }\n\n  has(name: string): boolean {\n    return this.#find(name) !== undefined;\n  }\n\n  /** Remove a variable by name. Returns whether one was removed. */\n  delete(name: string): boolean {\n    const i = this.#entries.findIndex((e) => e.metadata.name === name);\n    if (i === -1) return false;\n    this.#entries.splice(i, 1);\n    return true;\n  }\n\n  get size(): number {\n    return this.#entries.length;\n  }\n\n  [Symbol.iterator](): IterableIterator<Variable> {\n    return this.#entries.map((e) => e.variable)[Symbol.iterator]();\n  }\n\n  #find(name: string): VariableEntry | undefined {\n    return this.#entries.find((e) => e.metadata.name === name);\n  }\n}\n\n/**\n * A computed value evaluated at deploy time, compiled to a Bicep `var` declaration.\n *\n * @example\n * ```typescript snippet:ignore\n * import { Stack, createVariable } from \"@azure/provisioning-core\";\n *\n * const stack = new Stack(\"my-app\");\n * const suffix = createVariable(stack, \"suffix\", \"prod\");\n * ```\n */\nexport function createVariable<TValue extends VariableValue = VariableValue>(\n  stack: Stack,\n  name: string,\n  value: TValue,\n  options?: VariableOptions,\n): Variable<TValue> {\n  return stack.variables.add(name, value, options);\n}\n"]}

package/dist/esm/deployment-context/deployment-context.d.ts

@@ -0,0 +1,27 @@
+import type { ExpressionOrValue } from "../expression/expressions.js";
+import type { NamingPolicy } from "../naming/naming-policy.js";
+/**
+ * Inherited environment that flows down the component tree.
+ *
+ * @remarks
+ * Each node may attach a local contribution via `ProvisioningComponent._localDeploymentContext`
+ * (today, only `Stack` and `ResourceGroup` do). When a `Resource` reads the
+ * effective context, the framework walks ancestors and resolves each field:
+ *
+ * - `location`: nearest ancestor with a value wins.
+ * - `namingPolicy`: nearest ancestor with a value wins.
+ * - `tags`: flat-merged across **all** ancestors; innermost wins on key conflict.
+ *
+ * Per-resource Bicep `scope:` is not part of this — a resource's deployment
+ * scope is determined by which file or module it lands in, which in turn is
+ * determined by the ProvisioningComponent tree (the nearest `ResourceGroup`/`Stack` ancestor).
+ *
+ * The same interface describes both a node's local contribution and the
+ * fully-resolved view returned by `ProvisioningComponent.deploymentContext`.
+ */
+export interface DeploymentContext {
+    readonly location?: ExpressionOrValue<string> | undefined;
+    readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;
+    readonly namingPolicy?: NamingPolicy | undefined;
+}
+//# sourceMappingURL=deployment-context.d.ts.map

package/dist/esm/deployment-context/deployment-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-context.d.ts","sourceRoot":"","sources":["../../../src/deployment-context/deployment-context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACtE,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;CAClD"}

package/dist/esm/deployment-context/deployment-context.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=deployment-context.js.map

package/dist/esm/deployment-context/deployment-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-context.js","sourceRoot":"","sources":["../../../src/deployment-context/deployment-context.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { ExpressionOrValue } from \"../expression/expressions.js\";\nimport type { NamingPolicy } from \"../naming/naming-policy.js\";\n\n/**\n * Inherited environment that flows down the component tree.\n *\n * @remarks\n * Each node may attach a local contribution via `ProvisioningComponent._localDeploymentContext`\n * (today, only `Stack` and `ResourceGroup` do). When a `Resource` reads the\n * effective context, the framework walks ancestors and resolves each field:\n *\n * - `location`: nearest ancestor with a value wins.\n * - `namingPolicy`: nearest ancestor with a value wins.\n * - `tags`: flat-merged across **all** ancestors; innermost wins on key conflict.\n *\n * Per-resource Bicep `scope:` is not part of this — a resource's deployment\n * scope is determined by which file or module it lands in, which in turn is\n * determined by the ProvisioningComponent tree (the nearest `ResourceGroup`/`Stack` ancestor).\n *\n * The same interface describes both a node's local contribution and the\n * fully-resolved view returned by `ProvisioningComponent.deploymentContext`.\n */\nexport interface DeploymentContext {\n  readonly location?: ExpressionOrValue<string> | undefined;\n  readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;\n  readonly namingPolicy?: NamingPolicy | undefined;\n}\n"]}