@azure/provisioning-core 1.0.0-beta.1

package/dist/commonjs/expression/ast-nodes.js

@@ -0,0 +1,152 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ast_nodes_exports = {};
+__export(ast_nodes_exports, {
+  accessExpressionNode: () => accessExpressionNode,
+  arrayAccessExpressionNode: () => arrayAccessExpressionNode,
+  binaryExpressionNode: () => binaryExpressionNode,
+  functionCallExpressionNode: () => functionCallExpressionNode,
+  identifierExpressionNode: () => identifierExpressionNode,
+  instanceFunctionCallExpressionNode: () => instanceFunctionCallExpressionNode,
+  interpolatedStringExpressionNode: () => interpolatedStringExpressionNode,
+  isExpressionNode: () => isExpressionNode,
+  propertyAccessExpressionNode: () => propertyAccessExpressionNode,
+  symbolicValueExpressionNode: () => symbolicValueExpressionNode,
+  ternaryExpressionNode: () => ternaryExpressionNode,
+  unaryExpressionNode: () => unaryExpressionNode
+});
+module.exports = __toCommonJS(ast_nodes_exports);
+const EXPRESSION_NODE_KINDS = {
+  "fn-call": true,
+  "symbolic-value": true,
+  identifier: true,
+  "property-access": true,
+  "array-access": true,
+  binary: true,
+  unary: true,
+  ternary: true,
+  "instance-function-call": true,
+  "interpolated-string": true
+};
+function isExpressionNode(value) {
+  if (typeof value !== "object" || value === null || !Object.prototype.hasOwnProperty.call(value, "kind") || typeof value.kind !== "string") {
+    return false;
+  }
+  const node = value;
+  if (!Object.prototype.hasOwnProperty.call(EXPRESSION_NODE_KINDS, node.kind)) {
+    return false;
+  }
+  switch (node.kind) {
+    case "fn-call":
+      return typeof node.operator === "string" && Array.isArray(node.args);
+    case "symbolic-value":
+      return typeof node.path === "string";
+    case "identifier":
+      return typeof node.id === "string" || typeof node.id === "object";
+    case "property-access":
+      return isExpressionNode(node.base) && typeof node.property === "string" && typeof node.nullish === "boolean";
+    case "array-access":
+      return isExpressionNode(node.base) && "index" in node && typeof node.nullish === "boolean" && typeof node.fromEnd === "boolean";
+    case "binary":
+      return typeof node.operator === "string" && "left" in node && "right" in node;
+    case "unary":
+      return typeof node.operator === "string" && "argument" in node;
+    case "ternary":
+      return "condition" in node && "trueValue" in node && "falseValue" in node;
+    case "instance-function-call":
+      return isExpressionNode(node.base) && typeof node.name === "string" && Array.isArray(node.args);
+    case "interpolated-string":
+      return Array.isArray(node.segments);
+    default:
+      return false;
+  }
+}
+function functionCallExpressionNode(operator, args) {
+  return { kind: "fn-call", operator, args };
+}
+function symbolicValueExpressionNode(path) {
+  return { kind: "symbolic-value", path };
+}
+function identifierExpressionNode(identifier) {
+  return { kind: "identifier", id: identifier };
+}
+function propertyAccessExpressionNode(base, property, options = {}) {
+  return {
+    kind: "property-access",
+    base,
+    property,
+    nullish: options.nullish ?? false,
+    ...options.armPath === void 0 ? {} : { armPath: options.armPath }
+  };
+}
+function arrayAccessExpressionNode(base, index, options = {}) {
+  return {
+    kind: "array-access",
+    base,
+    index,
+    nullish: options.nullish ?? false,
+    fromEnd: options.fromEnd ?? false
+  };
+}
+function binaryExpressionNode(operator, left, right) {
+  return { kind: "binary", operator, left, right };
+}
+function unaryExpressionNode(operator, argument) {
+  return { kind: "unary", operator, argument };
+}
+function ternaryExpressionNode(condition, trueValue, falseValue) {
+  return {
+    kind: "ternary",
+    condition,
+    trueValue,
+    falseValue
+  };
+}
+function instanceFunctionCallExpressionNode(base, name, args) {
+  return {
+    kind: "instance-function-call",
+    base,
+    name,
+    args
+  };
+}
+function interpolatedStringExpressionNode(segments) {
+  return { kind: "interpolated-string", segments };
+}
+function isIdentifierSegment(segment) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(segment);
+}
+function accessExpressionNode(base, member, options = {}) {
+  return typeof member === "number" || !isIdentifierSegment(member) ? arrayAccessExpressionNode(base, member, options) : propertyAccessExpressionNode(base, member, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  accessExpressionNode,
+  arrayAccessExpressionNode,
+  binaryExpressionNode,
+  functionCallExpressionNode,
+  identifierExpressionNode,
+  instanceFunctionCallExpressionNode,
+  interpolatedStringExpressionNode,
+  isExpressionNode,
+  propertyAccessExpressionNode,
+  symbolicValueExpressionNode,
+  ternaryExpressionNode,
+  unaryExpressionNode
+});
+//# sourceMappingURL=ast-nodes.js.map

package/dist/commonjs/expression/ast-nodes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/expression/ast-nodes.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { Resource } from \"../constructs/resource/resource.js\";\nimport type { BinaryOperator, UnaryOperator } from \"../serialization/contract/index.js\";\nimport type { PropertySegment } from \"../types.js\";\n\nexport type { BinaryOperator, UnaryOperator };\n\n// ---------------------------------------------------------------------------\n// Expression node interfaces (the raw discriminated union members)\n// ---------------------------------------------------------------------------\n\n// Note: every interface declares a phantom `TValue` (when otherwise it wouldn't\n// need one). `TValue` is *not* used in any field of any interface \u2014 but its\n// presence in the variant *type-parameter slot* is what allows\n// `ExpressionNode<T>` to thread `T` through to each variant, which in turn is\n// what lets `ExpressionBrand<T>` carry inference-visible `T` across project-\n// reference boundaries. Removing `TValue` and making `ExpressionNode<T>` a\n// fully-phantom alias breaks `coalesce<T>(...)` inference and the\n// `as DeploymentParameter<...>` cast in cross-project consumers (e.g. `demo`).\n\nexport interface FunctionCallExpressionNode<_TValue = unknown, TOperator extends string = string> {\n  readonly kind: \"fn-call\";\n  readonly operator: TOperator;\n  readonly args: readonly unknown[];\n}\n\nexport interface SymbolicValueExpressionNode<_TValue = unknown, TPath extends string = string> {\n  readonly kind: \"symbolic-value\";\n  readonly path: TPath;\n}\n\nexport interface IdentifierExpressionNode<_TValue = unknown> {\n  readonly kind: \"identifier\";\n  readonly id: string | Resource;\n}\n\nexport interface PropertyAccessExpressionNode<_TValue = unknown> {\n  readonly kind: \"property-access\";\n  readonly base: ExpressionNode;\n  readonly property: string;\n  readonly nullish: boolean;\n  /**\n   * Optional ARM wire-path segments. When present, the serialization\n   * lowering pass rewrites this single access into a chain that walks\n   * these segments (handling renames + `@flattenProperty` hoisting).\n   * Untyped / hand-built expressions leave this `undefined` and pass\n   * through unchanged.\n   */\n  readonly armPath?: readonly string[] | undefined;\n}\n\nexport interface ArrayAccessExpressionNode<_TValue = unknown> {\n  readonly kind: \"array-access\";\n  readonly base: ExpressionNode;\n  /**\n   * The index into the array. A literal `number`/`string` lowers to an\n   * integer/string array-access (or a property-access for identifier-like\n   * strings) at serialize time. Any {@link ExpressionNode} is serialized\n   * recursively into the wire array-access's `index` slot \u2014 e.g. a looped\n   * `.at(loop.index)` stores the unwrapped `symbolic-value` node (emitting\n   * `sym[i]`), and a computed offset stores a `binary` / `fn-call` node\n   * (`sym[i + 1]`). `Expression<T>` proxies are always unwrapped to their\n   * raw node before landing here, per the \"state holds normalized raw\n   * nodes\" invariant \u2014 so a proxy is never stored directly.\n   */\n  readonly index: ArrayAccessIndex;\n  readonly nullish: boolean;\n  readonly fromEnd: boolean;\n}\n\nexport interface BinaryExpressionNode<_TValue = unknown> {\n  readonly kind: \"binary\";\n  readonly operator: BinaryOperator;\n  readonly left: unknown;\n  readonly right: unknown;\n}\n\nexport interface UnaryExpressionNode<_TValue = unknown> {\n  readonly kind: \"unary\";\n  readonly operator: UnaryOperator;\n  readonly argument: unknown;\n}\n\nexport interface TernaryExpressionNode<_TValue = unknown> {\n  readonly kind: \"ternary\";\n  readonly condition: unknown;\n  readonly trueValue: unknown;\n  readonly falseValue: unknown;\n}\n\nexport interface InstanceFunctionCallExpressionNode<_TValue = unknown> {\n  readonly kind: \"instance-function-call\";\n  readonly base: ExpressionNode;\n  readonly name: string;\n  readonly args: readonly unknown[];\n}\n\nexport interface InterpolatedStringExpressionNode<_TValue = unknown> {\n  readonly kind: \"interpolated-string\";\n  readonly segments: readonly unknown[];\n}\n\n// ---------------------------------------------------------------------------\n// ExpressionNode union\n// ---------------------------------------------------------------------------\n\n// `T` is threaded through every variant. See the long comment above the node\n// interfaces for why this matters.\nexport type ExpressionNode<T = unknown> =\n  | FunctionCallExpressionNode<T>\n  | SymbolicValueExpressionNode<T>\n  | IdentifierExpressionNode<T>\n  | PropertyAccessExpressionNode<T>\n  | ArrayAccessExpressionNode<T>\n  | BinaryExpressionNode<T>\n  | UnaryExpressionNode<T>\n  | TernaryExpressionNode<T>\n  | InstanceFunctionCallExpressionNode<T>\n  | InterpolatedStringExpressionNode<T>;\n\n/**\n * The index stored on an {@link ArrayAccessExpressionNode}: a literal\n * `number` or `string`, or a raw {@link ExpressionNode} evaluated at\n * serialize time (e.g. a loop's `symbolic-value` index, or a `binary` /\n * `fn-call` node for a computed offset). `Expression<T>` proxies are\n * unwrapped to their raw node before being stored, so the proxy type is\n * intentionally absent here.\n */\nexport type ArrayAccessIndex = number | string | ExpressionNode;\n\n// Typed as `Record<ExpressionNode[\"kind\"], true>` so adding a new variant to\n// `ExpressionNode` forces a compile error here until the new kind is listed.\nconst EXPRESSION_NODE_KINDS: Record<ExpressionNode[\"kind\"], true> = {\n  \"fn-call\": true,\n  \"symbolic-value\": true,\n  identifier: true,\n  \"property-access\": true,\n  \"array-access\": true,\n  binary: true,\n  unary: true,\n  ternary: true,\n  \"instance-function-call\": true,\n  \"interpolated-string\": true,\n};\n\n/** Tests whether a value structurally matches a raw expression AST node. */\nexport function isExpressionNode(value: unknown): value is ExpressionNode {\n  if (\n    typeof value !== \"object\" ||\n    value === null ||\n    !Object.prototype.hasOwnProperty.call(value, \"kind\") ||\n    typeof (value as { kind: unknown }).kind !== \"string\"\n  ) {\n    return false;\n  }\n  const node = value as Record<string, unknown>;\n  if (!Object.prototype.hasOwnProperty.call(EXPRESSION_NODE_KINDS, node.kind as string)) {\n    return false;\n  }\n  switch (node.kind) {\n    case \"fn-call\":\n      return typeof node.operator === \"string\" && Array.isArray(node.args);\n    case \"symbolic-value\":\n      return typeof node.path === \"string\";\n    case \"identifier\":\n      return typeof node.id === \"string\" || typeof node.id === \"object\";\n    case \"property-access\":\n      return (\n        isExpressionNode(node.base) &&\n        typeof node.property === \"string\" &&\n        typeof node.nullish === \"boolean\"\n      );\n    case \"array-access\":\n      return (\n        isExpressionNode(node.base) &&\n        \"index\" in node &&\n        typeof node.nullish === \"boolean\" &&\n        typeof node.fromEnd === \"boolean\"\n      );\n    case \"binary\":\n      return typeof node.operator === \"string\" && \"left\" in node && \"right\" in node;\n    case \"unary\":\n      return typeof node.operator === \"string\" && \"argument\" in node;\n    case \"ternary\":\n      return \"condition\" in node && \"trueValue\" in node && \"falseValue\" in node;\n    case \"instance-function-call\":\n      return (\n        isExpressionNode(node.base) && typeof node.name === \"string\" && Array.isArray(node.args)\n      );\n    case \"interpolated-string\":\n      return Array.isArray(node.segments);\n    default:\n      return false;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory functions\n// ---------------------------------------------------------------------------\n\nexport function functionCallExpressionNode<TValue = unknown, TOperator extends string = string>(\n  operator: TOperator,\n  args: readonly unknown[],\n): FunctionCallExpressionNode<TValue, TOperator> {\n  return { kind: \"fn-call\", operator, args };\n}\n\nexport function symbolicValueExpressionNode<TValue = unknown, TPath extends string = string>(\n  path: TPath,\n): SymbolicValueExpressionNode<TValue, TPath> {\n  return { kind: \"symbolic-value\", path };\n}\n\nexport function identifierExpressionNode<TValue = unknown>(\n  identifier: string | Resource,\n): IdentifierExpressionNode<TValue> {\n  return { kind: \"identifier\", id: identifier };\n}\n\nexport function propertyAccessExpressionNode<TValue = unknown>(\n  base: ExpressionNode,\n  property: string,\n  options: Partial<Pick<PropertyAccessExpressionNode, \"armPath\" | \"nullish\">> = {},\n): PropertyAccessExpressionNode<TValue> {\n  return {\n    kind: \"property-access\",\n    base,\n    property,\n    nullish: options.nullish ?? false,\n    ...(options.armPath === undefined ? {} : { armPath: options.armPath }),\n  };\n}\n\nexport function arrayAccessExpressionNode<TValue = unknown>(\n  base: ExpressionNode,\n  index: ArrayAccessIndex,\n  options: Partial<Pick<ArrayAccessExpressionNode, \"nullish\" | \"fromEnd\">> = {},\n): ArrayAccessExpressionNode<TValue> {\n  return {\n    kind: \"array-access\",\n    base,\n    index,\n    nullish: options.nullish ?? false,\n    fromEnd: options.fromEnd ?? false,\n  };\n}\n\nexport function binaryExpressionNode<TValue = unknown>(\n  operator: BinaryOperator,\n  left: unknown,\n  right: unknown,\n): BinaryExpressionNode<TValue> {\n  return { kind: \"binary\", operator, left, right };\n}\n\nexport function unaryExpressionNode<TValue = unknown>(\n  operator: UnaryOperator,\n  argument: unknown,\n): UnaryExpressionNode<TValue> {\n  return { kind: \"unary\", operator, argument };\n}\n\nexport function ternaryExpressionNode<TValue = unknown>(\n  condition: unknown,\n  trueValue: unknown,\n  falseValue: unknown,\n): TernaryExpressionNode<TValue> {\n  return {\n    kind: \"ternary\",\n    condition,\n    trueValue,\n    falseValue,\n  };\n}\n\nexport function instanceFunctionCallExpressionNode<TValue = unknown>(\n  base: ExpressionNode,\n  name: string,\n  args: readonly unknown[],\n): InstanceFunctionCallExpressionNode<TValue> {\n  return {\n    kind: \"instance-function-call\",\n    base,\n    name,\n    args,\n  };\n}\n\nexport function interpolatedStringExpressionNode<TValue = unknown>(\n  segments: readonly unknown[],\n): InterpolatedStringExpressionNode<TValue> {\n  return { kind: \"interpolated-string\", segments };\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nfunction isIdentifierSegment(segment: string): boolean {\n  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(segment);\n}\n\nexport function accessExpressionNode(\n  base: ExpressionNode,\n  member: PropertySegment,\n  options: Partial<Pick<PropertyAccessExpressionNode, \"armPath\" | \"nullish\">> = {},\n): PropertyAccessExpressionNode | ArrayAccessExpressionNode {\n  return typeof member === \"number\" || !isIdentifierSegment(member)\n    ? arrayAccessExpressionNode(base, member, options)\n    : propertyAccessExpressionNode(base, member, options);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/commonjs/expression/expressions.d.ts

@@ -0,0 +1,164 @@
+import { type NavShape } from "../shape/shape.js";
+import { type BinaryOperator, type ExpressionNode, type UnaryOperator } from "./ast-nodes.js";
+/**
+ * Runtime symbol key storing the underlying `ExpressionNode` on proxies.
+ * Internal to the package — consumers should use `isExpression()` and
+ * `unwrapExpression()` instead of accessing this directly.
+ */
+export declare const EXPRESSION_BRAND: unique symbol;
+/** Declared symbol type used in the `Expression<T>` interface for branding. */
+declare const __expressionBrand: unique symbol;
+export interface ExpressionBrand<out T> {
+    readonly [__expressionBrand]: ExpressionNode<T>;
+}
+declare const __expressionTag: unique symbol;
+export interface ExpressionTag {
+    readonly [__expressionTag]?: never;
+}
+/**
+ * An opaque deploy-time expression wrapping type `T`.
+ *
+ * For object types, properties of `T` are accessible as
+ * `Expression<Exclude<T[K], undefined>>`. Expression proxies always expose a
+ * symbolic property path, so TypeScript's `undefined` omission marker does not
+ * belong in the projected value type. Explicit `null` remains intact.
+ * For array types, numeric indices return `Expression<element>` and
+ * `.length` is an `Expression<number>`.
+ *
+ * Function-typed keys on `T` are intentionally NOT surfaced — an
+ * `Expression<(...)=>R>` isn't callable at the type level or meaningful
+ * at emit time. When bicep-level array/object methods are needed
+ * (concat, union, etc.), they are added explicitly via dedicated helper
+ * types (e.g. a future `ArrayExpression<T>`), not reflectively derived.
+ *
+ * `NonNullable<T>` is applied at the input boundary, so
+ * `Expression<R | undefined>` yields the same structural surface as
+ * `Expression<R>` — otherwise the `| undefined` union would distribute
+ * and collapse the object branch into `mapped | {}`, erasing the
+ * index signature / member projection.
+ */
+export type Expression<T = unknown> = ExpressionBrand<T> & ExpressionTag & ExpressionShape<NonNullable<T>>;
+export type ExpressionShape<T> = T extends readonly unknown[] ? number extends T["length"] ? {
+    readonly length: Expression<number>;
+    readonly [index: number]: Expression<T[number]>;
+} : {
+    readonly [K in Exclude<keyof T, keyof any[]>]: Expression<T[K]>;
+} & {
+    readonly length: Expression<number>;
+    readonly [index: number]: Expression<T[number]>;
+} : T extends object ? {
+    readonly [K in keyof T as T[K] extends (...a: any[]) => any ? never : K]-?: Expression<Exclude<T[K], undefined>>;
+} : {};
+/**
+ * Carries an *optional* Expression brand on an Input-shaped interface.
+ *
+ * This is the asymmetric-brand trick that makes the Input type system
+ * work without discriminated unions:
+ *
+ * - Every generated `*Input` interface extends `InputOf<Raw>` and therefore
+ *   inherits the optional brand. Plain literal values (e.g. `{ foo: 1 }`)
+ *   trivially satisfy it because the brand property is absent, which is
+ *   permitted by an optional field.
+ * - `Expression<Raw>` carries a *required* brand of the same shape.
+ *   Required-fields-satisfy-optional is part of TS structural assignability,
+ *   so any `Expression<Raw>` is assignable where an `InputOf<Raw>`
+ *   (and thus any `*Input` that extends it) is expected.
+ *
+ * Net effect: a single `MInput` parameter accepts both literals and
+ * whole-subtree `Expression<M>` replacements — no `MInput | Expression<M>`
+ * union is needed in the generated signatures. Callers that want to
+ * inspect whether a value is a literal or expression use `isExpression()`.
+ */
+export interface InputOf<out Raw> {
+    readonly [__expressionBrand]?: ExpressionNode<Raw>;
+}
+/**
+ * Writable input form for an array container.
+ *
+ * Accepts literal `T[]`, another `InputArray<T>`, or `Expression<Raw>`.
+ * Deliberately NOT a subtype of `T[]` — passing a CDK-backed array to
+ * an API that expects a plain `Array<T>` fails at compile time, which
+ * is the correct signal (the value may actually be a Proxy wrapping an
+ * `ExpressionNode`, not a real JS array).
+ */
+export interface InputArray<T, Raw = readonly T[]> extends InputOf<Raw> {
+    length: number | Expression<number>;
+    [index: number]: T;
+}
+/** Writable input form for a `Record<string, V>` container. */
+export interface InputRecord<V, Raw = Record<string, V>> extends InputOf<Raw> {
+    [key: string]: V;
+}
+/** Writable input form for a fixed-length heterogeneous tuple. */
+export type InputTuple<T extends readonly unknown[], Raw extends readonly unknown[] = T> = InputOf<Raw> & {
+    length: T["length"] | Expression<number>;
+    [index: number]: T[number] | Expression<Raw[number]>;
+} & {
+    [K in Exclude<keyof T, keyof any[]>]: T[K];
+};
+/**
+ * Accepts either a plain value `T` or an `Expression<T>` substitution.
+ *
+ * Use this on scalar/leaf Input sites (primitives, enums, literal-only
+ * unions) where a full `InputOf<...>` structural extension doesn't apply.
+ * The result is a simple discriminated union; call `isExpression()` to
+ * branch on the runtime shape.
+ */
+export type ExpressionOrValue<T> = T | Expression<T>;
+/**
+ * Asserts that a deploy-time expression resolves to a specific literal,
+ * so it can be used where a discriminator is expected.
+ *
+ * Discriminator properties on a `@discriminator` model are typed as bare
+ * literals (`kind: "cache"`) rather than `ExpressionOrValue<"cache">`.
+ * That is deliberate: TypeScript only treats a property as a discriminant
+ * when its type is a *unit* type in every constituent of the union, and a
+ * single widened arm disables narrowing for the whole union — completions
+ * then offer every variant's properties and excess-property checking
+ * degrades to "allowed if the property exists in any variant".
+ *
+ * When the discriminator genuinely isn't known until deployment, wrap the
+ * expression with this to state which variant you mean:
+ *
+ * ```ts snippet:ignore
+ * widget.properties.primaryRule = {
+ *   kind: asDiscriminator(kindParam),
+ *   cacheKind: "long",
+ *   days: 7,
+ * };
+ * ```
+ *
+ * Every other property is still fully checked — only the discriminator's
+ * type safety is waived. Note that the runtime cannot dispatch on a
+ * non-literal discriminator, so serialization falls back to structural
+ * variant inference; prefer a literal wherever possible.
+ *
+ * The literal is inferred from the expression's own type argument. If the
+ * expression is loosely typed (`Expression<string>`), name the variant
+ * explicitly: `asDiscriminator<"cache">(param)`.
+ */
+export declare function asDiscriminator<L extends string>(value: ExpressionOrValue<L>): L;
+/**
+ * Extracts the underlying `ExpressionNode` from an `Expression<T>` value.
+ *
+ * `Expression<T>` is the public, typed handle for a deploy-time expression
+ * (backed by a Proxy at runtime); `ExpressionNode` is the raw AST node that
+ * the proxy wraps. Use this to walk / inspect / serialize the underlying
+ * tree without reaching for the brand symbol directly.
+ */
+export declare function unwrapExpression<T>(expr: Expression<T>): ExpressionNode<T>;
+/**
+ * Tests whether a value is an `Expression<T>` — the typed, branded handle
+ * for a deploy-time expression (proxy-backed). Returns false for raw
+ * `ExpressionNode` data; use {@link isExpressionNode} from `./ast-nodes.js`
+ * for that.
+ */
+export declare function isExpression(value: unknown): value is Expression<unknown>;
+export declare function wrapExpression<T = unknown>(expression: ExpressionNode, nav?: NavShape): Expression<T>;
+export declare function wrapExpressionOver<TObject extends object, TValue = unknown>(target: TObject, expression: ExpressionNode): TObject & Expression<TValue>;
+export declare function createBinaryExpression<T>(op: BinaryOperator, left: unknown, right: unknown): Expression<T>;
+export declare function createUnaryExpression<T>(op: UnaryOperator, argument: unknown): Expression<T>;
+export declare function createTernaryExpression<T>(condition: unknown, trueValue: unknown, falseValue: unknown): Expression<T>;
+export declare function createFunctionCallExpression<T>(name: string, args: unknown[]): Expression<T>;
+export {};
+//# sourceMappingURL=expressions.d.ts.map

package/dist/commonjs/expression/expressions.d.ts.map

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

package/dist/commonjs/expression/expressions.js

@@ -0,0 +1,171 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var expressions_exports = {};
+__export(expressions_exports, {
+  EXPRESSION_BRAND: () => EXPRESSION_BRAND,
+  asDiscriminator: () => asDiscriminator,
+  createBinaryExpression: () => createBinaryExpression,
+  createFunctionCallExpression: () => createFunctionCallExpression,
+  createTernaryExpression: () => createTernaryExpression,
+  createUnaryExpression: () => createUnaryExpression,
+  isExpression: () => isExpression,
+  unwrapExpression: () => unwrapExpression,
+  wrapExpression: () => wrapExpression,
+  wrapExpressionOver: () => wrapExpressionOver
+});
+module.exports = __toCommonJS(expressions_exports);
+var import_shape = require("../shape/shape.js");
+var import_ast_nodes = require("./ast-nodes.js");
+const EXPRESSION_BRAND = /* @__PURE__ */ Symbol("expression-brand");
+function asDiscriminator(value) {
+  return value;
+}
+function unwrapExpression(expr) {
+  return expr[EXPRESSION_BRAND];
+}
+function isExpression(value) {
+  return typeof value === "object" && value !== null && EXPRESSION_BRAND in value;
+}
+function wrapExpression(expression, nav) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, prop, _receiver) {
+      if (prop === EXPRESSION_BRAND) {
+        return expression;
+      }
+      if (prop === Symbol.toPrimitive || prop === "toString") {
+        return () => "[Expression]";
+      }
+      if (prop === "valueOf") {
+        return () => expression;
+      }
+      if (prop === "then") {
+        return void 0;
+      }
+      if (typeof prop === "symbol") {
+        return void 0;
+      }
+      if (/^\d+$/u.test(prop)) {
+        const index = Number(prop);
+        const step2 = (0, import_shape.navigateShape)(nav, index);
+        return wrapExpression(
+          (0, import_ast_nodes.arrayAccessExpressionNode)(expression, index),
+          step2.next
+        );
+      }
+      const step = (0, import_shape.navigateShape)(nav, prop);
+      return wrapExpression(
+        (0, import_ast_nodes.propertyAccessExpressionNode)(expression, prop, {
+          armPath: step.stamp?.armPath
+        }),
+        step.next
+      );
+    },
+    has(_target, prop) {
+      return prop === EXPRESSION_BRAND;
+    },
+    ownKeys() {
+      return [];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (prop === EXPRESSION_BRAND) {
+        return {
+          configurable: true,
+          enumerable: false,
+          value: expression
+        };
+      }
+      return void 0;
+    }
+  });
+}
+function wrapExpressionOver(target, expression) {
+  return new Proxy(target, {
+    get(backing, prop, receiver) {
+      if (prop === EXPRESSION_BRAND) {
+        return expression;
+      }
+      if (prop === Symbol.toPrimitive || prop === "toString") {
+        return () => "[Expression]";
+      }
+      if (prop === "valueOf") {
+        return () => expression;
+      }
+      if (prop === "then") {
+        return void 0;
+      }
+      if (Reflect.has(backing, prop)) {
+        return Reflect.get(backing, prop, receiver);
+      }
+      if (typeof prop === "symbol") {
+        return void 0;
+      }
+      if (/^\d+$/u.test(prop)) {
+        return wrapExpression(
+          (0, import_ast_nodes.arrayAccessExpressionNode)(expression, Number(prop))
+        );
+      }
+      return wrapExpression((0, import_ast_nodes.propertyAccessExpressionNode)(expression, prop));
+    },
+    has(backing, prop) {
+      return prop === EXPRESSION_BRAND || Reflect.has(backing, prop);
+    },
+    ownKeys(backing) {
+      const keys = Reflect.ownKeys(backing);
+      if (!keys.includes(EXPRESSION_BRAND)) {
+        keys.push(EXPRESSION_BRAND);
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(backing, prop) {
+      if (prop === EXPRESSION_BRAND) {
+        return {
+          configurable: true,
+          enumerable: false,
+          value: expression
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(backing, prop);
+    }
+  });
+}
+function createBinaryExpression(op, left, right) {
+  return wrapExpression((0, import_ast_nodes.binaryExpressionNode)(op, left, right));
+}
+function createUnaryExpression(op, argument) {
+  return wrapExpression((0, import_ast_nodes.unaryExpressionNode)(op, argument));
+}
+function createTernaryExpression(condition, trueValue, falseValue) {
+  return wrapExpression((0, import_ast_nodes.ternaryExpressionNode)(condition, trueValue, falseValue));
+}
+function createFunctionCallExpression(name, args) {
+  return wrapExpression((0, import_ast_nodes.functionCallExpressionNode)(name, args));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXPRESSION_BRAND,
+  asDiscriminator,
+  createBinaryExpression,
+  createFunctionCallExpression,
+  createTernaryExpression,
+  createUnaryExpression,
+  isExpression,
+  unwrapExpression,
+  wrapExpression,
+  wrapExpressionOver
+});
+//# sourceMappingURL=expressions.js.map

package/dist/commonjs/expression/expressions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/expression/expressions.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { navigateShape, type NavShape } from \"../shape/shape.js\";\nimport {\n  arrayAccessExpressionNode,\n  binaryExpressionNode,\n  functionCallExpressionNode,\n  propertyAccessExpressionNode,\n  ternaryExpressionNode,\n  type BinaryOperator,\n  type ExpressionNode,\n  type UnaryOperator,\n  unaryExpressionNode,\n} from \"./ast-nodes.js\";\n\n// ---------------------------------------------------------------------------\n// Brand symbol (runtime + type-only)\n// ---------------------------------------------------------------------------\n\n/**\n * Runtime symbol key storing the underlying `ExpressionNode` on proxies.\n * Internal to the package \u2014 consumers should use `isExpression()` and\n * `unwrapExpression()` instead of accessing this directly.\n */\nexport const EXPRESSION_BRAND: unique symbol = Symbol(\"expression-brand\");\n\n/** Declared symbol type used in the `Expression<T>` interface for branding. */\ndeclare const __expressionBrand: unique symbol;\n\n// ---------------------------------------------------------------------------\n// Public opaque Expression<T> type\n// ---------------------------------------------------------------------------\n\nexport interface ExpressionBrand<out T> {\n  readonly [__expressionBrand]: ExpressionNode<T>;\n}\n\n// Prevents TypeScript from simplifying `Expression<primitive>` down to\n// just `ExpressionBrand<primitive>` \u2014 keeps the alias name visible in hovers.\n// Symbol-keyed so it stays hidden from IntelliSense.\ndeclare const __expressionTag: unique symbol;\nexport interface ExpressionTag {\n  readonly [__expressionTag]?: never;\n}\n\n/**\n * An opaque deploy-time expression wrapping type `T`.\n *\n * For object types, properties of `T` are accessible as\n * `Expression<Exclude<T[K], undefined>>`. Expression proxies always expose a\n * symbolic property path, so TypeScript's `undefined` omission marker does not\n * belong in the projected value type. Explicit `null` remains intact.\n * For array types, numeric indices return `Expression<element>` and\n * `.length` is an `Expression<number>`.\n *\n * Function-typed keys on `T` are intentionally NOT surfaced \u2014 an\n * `Expression<(...)=>R>` isn't callable at the type level or meaningful\n * at emit time. When bicep-level array/object methods are needed\n * (concat, union, etc.), they are added explicitly via dedicated helper\n * types (e.g. a future `ArrayExpression<T>`), not reflectively derived.\n *\n * `NonNullable<T>` is applied at the input boundary, so\n * `Expression<R | undefined>` yields the same structural surface as\n * `Expression<R>` \u2014 otherwise the `| undefined` union would distribute\n * and collapse the object branch into `mapped | {}`, erasing the\n * index signature / member projection.\n */\nexport type Expression<T = unknown> = ExpressionBrand<T> &\n  ExpressionTag &\n  ExpressionShape<NonNullable<T>>;\n\nexport type ExpressionShape<T> = T extends readonly unknown[]\n  ? number extends T[\"length\"]\n    ? {\n        readonly length: Expression<number>;\n        readonly [index: number]: Expression<T[number]>;\n      }\n    : {\n        readonly [K in Exclude<keyof T, keyof any[]>]: Expression<T[K]>;\n      } & {\n        readonly length: Expression<number>;\n        readonly [index: number]: Expression<T[number]>;\n      }\n  : T extends object\n    ? {\n        readonly [K in keyof T as T[K] extends (...a: any[]) => any ? never : K]-?: Expression<\n          Exclude<T[K], undefined>\n        >;\n      }\n    : {};\n\n// ---------------------------------------------------------------------------\n// Input-side types \u2014 optional-brand trick\n// ---------------------------------------------------------------------------\n\n/**\n * Carries an *optional* Expression brand on an Input-shaped interface.\n *\n * This is the asymmetric-brand trick that makes the Input type system\n * work without discriminated unions:\n *\n * - Every generated `*Input` interface extends `InputOf<Raw>` and therefore\n *   inherits the optional brand. Plain literal values (e.g. `{ foo: 1 }`)\n *   trivially satisfy it because the brand property is absent, which is\n *   permitted by an optional field.\n * - `Expression<Raw>` carries a *required* brand of the same shape.\n *   Required-fields-satisfy-optional is part of TS structural assignability,\n *   so any `Expression<Raw>` is assignable where an `InputOf<Raw>`\n *   (and thus any `*Input` that extends it) is expected.\n *\n * Net effect: a single `MInput` parameter accepts both literals and\n * whole-subtree `Expression<M>` replacements \u2014 no `MInput | Expression<M>`\n * union is needed in the generated signatures. Callers that want to\n * inspect whether a value is a literal or expression use `isExpression()`.\n */\nexport interface InputOf<out Raw> {\n  readonly [__expressionBrand]?: ExpressionNode<Raw>;\n}\n\n/**\n * Writable input form for an array container.\n *\n * Accepts literal `T[]`, another `InputArray<T>`, or `Expression<Raw>`.\n * Deliberately NOT a subtype of `T[]` \u2014 passing a CDK-backed array to\n * an API that expects a plain `Array<T>` fails at compile time, which\n * is the correct signal (the value may actually be a Proxy wrapping an\n * `ExpressionNode`, not a real JS array).\n */\nexport interface InputArray<T, Raw = readonly T[]> extends InputOf<Raw> {\n  length: number | Expression<number>;\n  [index: number]: T;\n}\n\n/** Writable input form for a `Record<string, V>` container. */\nexport interface InputRecord<V, Raw = Record<string, V>> extends InputOf<Raw> {\n  [key: string]: V;\n}\n\n/** Writable input form for a fixed-length heterogeneous tuple. */\nexport type InputTuple<\n  T extends readonly unknown[],\n  Raw extends readonly unknown[] = T,\n> = InputOf<Raw> & {\n  length: T[\"length\"] | Expression<number>;\n  [index: number]: T[number] | Expression<Raw[number]>;\n} & {\n  [K in Exclude<keyof T, keyof any[]>]: T[K];\n};\n\n// ---------------------------------------------------------------------------\n// ExpressionOrValue\n// ---------------------------------------------------------------------------\n\n/**\n * Accepts either a plain value `T` or an `Expression<T>` substitution.\n *\n * Use this on scalar/leaf Input sites (primitives, enums, literal-only\n * unions) where a full `InputOf<...>` structural extension doesn't apply.\n * The result is a simple discriminated union; call `isExpression()` to\n * branch on the runtime shape.\n */\nexport type ExpressionOrValue<T> = T | Expression<T>;\n\n// ---------------------------------------------------------------------------\n// Discriminator escape hatch\n// ---------------------------------------------------------------------------\n\n/**\n * Asserts that a deploy-time expression resolves to a specific literal,\n * so it can be used where a discriminator is expected.\n *\n * Discriminator properties on a `@discriminator` model are typed as bare\n * literals (`kind: \"cache\"`) rather than `ExpressionOrValue<\"cache\">`.\n * That is deliberate: TypeScript only treats a property as a discriminant\n * when its type is a *unit* type in every constituent of the union, and a\n * single widened arm disables narrowing for the whole union \u2014 completions\n * then offer every variant's properties and excess-property checking\n * degrades to \"allowed if the property exists in any variant\".\n *\n * When the discriminator genuinely isn't known until deployment, wrap the\n * expression with this to state which variant you mean:\n *\n * ```ts snippet:ignore\n * widget.properties.primaryRule = {\n *   kind: asDiscriminator(kindParam),\n *   cacheKind: \"long\",\n *   days: 7,\n * };\n * ```\n *\n * Every other property is still fully checked \u2014 only the discriminator's\n * type safety is waived. Note that the runtime cannot dispatch on a\n * non-literal discriminator, so serialization falls back to structural\n * variant inference; prefer a literal wherever possible.\n *\n * The literal is inferred from the expression's own type argument. If the\n * expression is loosely typed (`Expression<string>`), name the variant\n * explicitly: `asDiscriminator<\"cache\">(param)`.\n */\nexport function asDiscriminator<L extends string>(value: ExpressionOrValue<L>): L {\n  return value as L;\n}\n\n// ---------------------------------------------------------------------------\n// Unwrap + type guards\n// ---------------------------------------------------------------------------\n\n// Two distinct concepts, two distinct guards:\n//\n//   - `isExpression(x)`     \u2014 \"is `x` a typed `Expression<T>` handle\n//                             (the value-level, proxy-backed form)?\"\n//   - `isExpressionNode(x)` \u2014 \"is `x` a raw `ExpressionNode` data object\n//                             (one of the AST kinds)?\"\n//\n// These are *disjoint* \u2014 a value is either a wrapped Expression handle or a\n// raw AST node, never both. To check the AST kind of either form, narrow\n// via the discriminated `kind` field:\n//\n//   if (isExpression(value)) {\n//     const node = unwrapExpression(value);\n//     if (node.kind === \"fn-call\") { /* node: FunctionCallExpressionNode */ }\n//   }\n//   if (isExpressionNode(value)) {\n//     if (value.kind === \"binary\") { /* value: BinaryExpressionNode */ }\n//   }\n\n/**\n * Extracts the underlying `ExpressionNode` from an `Expression<T>` value.\n *\n * `Expression<T>` is the public, typed handle for a deploy-time expression\n * (backed by a Proxy at runtime); `ExpressionNode` is the raw AST node that\n * the proxy wraps. Use this to walk / inspect / serialize the underlying\n * tree without reaching for the brand symbol directly.\n */\nexport function unwrapExpression<T>(expr: Expression<T>): ExpressionNode<T> {\n  return (expr as unknown as { [EXPRESSION_BRAND]: ExpressionNode<T> })[EXPRESSION_BRAND];\n}\n\n/**\n * Tests whether a value is an `Expression<T>` \u2014 the typed, branded handle\n * for a deploy-time expression (proxy-backed). Returns false for raw\n * `ExpressionNode` data; use {@link isExpressionNode} from `./ast-nodes.js`\n * for that.\n */\nexport function isExpression(value: unknown): value is Expression<unknown> {\n  return typeof value === \"object\" && value !== null && EXPRESSION_BRAND in value;\n}\n\n// ---------------------------------------------------------------------------\n// Expression proxy factory\n// ---------------------------------------------------------------------------\n\nexport function wrapExpression<T = unknown>(\n  expression: ExpressionNode,\n  nav?: NavShape,\n): Expression<T> {\n  return new Proxy(Object.create(null) as Expression<T>, {\n    get(_target, prop, _receiver) {\n      if (prop === EXPRESSION_BRAND) {\n        return expression;\n      }\n\n      if (prop === Symbol.toPrimitive || prop === \"toString\") {\n        return () => \"[Expression]\";\n      }\n\n      if (prop === \"valueOf\") {\n        return () => expression;\n      }\n\n      // Avoid being treated as a thenable / Promise\n      if (prop === \"then\") {\n        return undefined;\n      }\n\n      if (typeof prop === \"symbol\") {\n        return undefined;\n      }\n\n      // Numeric string \u2192 array access.\n      if (/^\\d+$/u.test(prop)) {\n        const index = Number(prop);\n        const step = navigateShape(nav, index);\n        return wrapExpression(\n          arrayAccessExpressionNode(expression as ExpressionNode, index),\n          step.next,\n        );\n      }\n\n      // String property \u2192 property access. Consult the current nav\n      // shape; stamp the access with the wire armPath if an entry\n      // exists, otherwise pass through unchanged. Container navs\n      // (record/array) yield no stamp but still peel a layer.\n      const step = navigateShape(nav, prop);\n      return wrapExpression(\n        propertyAccessExpressionNode(expression as ExpressionNode, prop, {\n          armPath: step.stamp?.armPath,\n        }),\n        step.next,\n      );\n    },\n\n    has(_target, prop) {\n      return prop === EXPRESSION_BRAND;\n    },\n\n    ownKeys() {\n      return [];\n    },\n\n    getOwnPropertyDescriptor(_target, prop) {\n      if (prop === EXPRESSION_BRAND) {\n        return {\n          configurable: true,\n          enumerable: false,\n          value: expression,\n        };\n      }\n      return undefined;\n    },\n  });\n}\n\nexport function wrapExpressionOver<TObject extends object, TValue = unknown>(\n  target: TObject,\n  expression: ExpressionNode,\n): TObject & Expression<TValue> {\n  return new Proxy(target as TObject & Expression<TValue>, {\n    get(backing, prop, receiver) {\n      if (prop === EXPRESSION_BRAND) {\n        return expression;\n      }\n\n      if (prop === Symbol.toPrimitive || prop === \"toString\") {\n        return () => \"[Expression]\";\n      }\n\n      if (prop === \"valueOf\") {\n        return () => expression;\n      }\n\n      if (prop === \"then\") {\n        return undefined;\n      }\n\n      if (Reflect.has(backing, prop)) {\n        return Reflect.get(backing, prop, receiver);\n      }\n\n      if (typeof prop === \"symbol\") {\n        return undefined;\n      }\n\n      if (/^\\d+$/u.test(prop)) {\n        return wrapExpression(\n          arrayAccessExpressionNode(expression as ExpressionNode, Number(prop)),\n        );\n      }\n\n      return wrapExpression(propertyAccessExpressionNode(expression as ExpressionNode, prop));\n    },\n\n    has(backing, prop) {\n      return prop === EXPRESSION_BRAND || Reflect.has(backing, prop);\n    },\n\n    ownKeys(backing) {\n      const keys = Reflect.ownKeys(backing);\n      if (!keys.includes(EXPRESSION_BRAND)) {\n        keys.push(EXPRESSION_BRAND);\n      }\n      return keys;\n    },\n\n    getOwnPropertyDescriptor(backing, prop) {\n      if (prop === EXPRESSION_BRAND) {\n        return {\n          configurable: true,\n          enumerable: false,\n          value: expression,\n        };\n      }\n      return Reflect.getOwnPropertyDescriptor(backing, prop);\n    },\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Proxied-expression factories (return Expression<T>)\n// ---------------------------------------------------------------------------\n\nexport function createBinaryExpression<T>(\n  op: BinaryOperator,\n  left: unknown,\n  right: unknown,\n): Expression<T> {\n  return wrapExpression(binaryExpressionNode(op, left, right));\n}\n\nexport function createUnaryExpression<T>(op: UnaryOperator, argument: unknown): Expression<T> {\n  return wrapExpression(unaryExpressionNode(op, argument));\n}\n\nexport function createTernaryExpression<T>(\n  condition: unknown,\n  trueValue: unknown,\n  falseValue: unknown,\n): Expression<T> {\n  return wrapExpression(ternaryExpressionNode(condition, trueValue, falseValue));\n}\n\nexport function createFunctionCallExpression<T>(name: string, args: unknown[]): Expression<T> {\n  return wrapExpression(functionCallExpressionNode(name, args));\n}\n"],
+  "mappings": "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",
+  "names": ["step"]
+}