@azure/provisioning-core 1.0.0-beta.1

package/dist/commonjs/shape/shape.js

@@ -0,0 +1,290 @@
+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 shape_exports = {};
+__export(shape_exports, {
+  createAnyShape: () => createAnyShape,
+  createArrayShape: () => createArrayShape,
+  createBooleanLiteralShape: () => createBooleanLiteralShape,
+  createBooleanShape: () => createBooleanShape,
+  createBytesShape: () => createBytesShape,
+  createDateShape: () => createDateShape,
+  createDeferredShape: () => createDeferredShape,
+  createDiscriminatedModelShape: () => createDiscriminatedModelShape,
+  createEnumShape: () => createEnumShape,
+  createFlatModelShape: () => createFlatModelShape,
+  createNullShape: () => createNullShape,
+  createNumberLiteralShape: () => createNumberLiteralShape,
+  createNumberShape: () => createNumberShape,
+  createRecordShape: () => createRecordShape,
+  createStringLiteralShape: () => createStringLiteralShape,
+  createStringShape: () => createStringShape,
+  createTupleShape: () => createTupleShape,
+  createUnionShape: () => createUnionShape,
+  isTerminalValueShape: () => isTerminalValueShape,
+  navigateShape: () => navigateShape,
+  resolveModelShape: () => resolveModelShape
+});
+module.exports = __toCommonJS(shape_exports);
+const createFlatModelShape = (byJsName) => ({
+  kind: "flatModel",
+  byJsName
+});
+const createDiscriminatedModelShape = (discriminator, byValue) => ({
+  kind: "discriminatedModel",
+  discriminator: typeof discriminator === "string" ? { jsName: discriminator, armName: discriminator } : discriminator,
+  byValue
+});
+const createDeferredShape = (value) => ({
+  kind: "deferred",
+  value
+});
+const createAnyShape = () => ({ kind: "any" });
+const createStringShape = (encoding) => ({
+  kind: "string",
+  ...encoding ? { encoding } : {}
+});
+const createBooleanShape = (encoding) => ({
+  kind: "boolean",
+  ...encoding ? { encoding } : {}
+});
+const createNumberShape = (encoding) => ({
+  kind: "number",
+  ...encoding ? { encoding } : {}
+});
+const createBytesShape = (encoding) => ({
+  kind: "bytes",
+  ...encoding ? { encoding } : {}
+});
+const createDateShape = (encoding) => ({
+  kind: "date",
+  ...encoding ? { encoding } : {}
+});
+const createStringLiteralShape = () => ({
+  kind: "stringLiteral"
+});
+const createNumberLiteralShape = (encoding) => ({
+  kind: "numberLiteral",
+  ...encoding ? { encoding } : {}
+});
+const createBooleanLiteralShape = (encoding) => ({
+  kind: "booleanLiteral",
+  ...encoding ? { encoding } : {}
+});
+const createEnumShape = () => ({ kind: "enum" });
+const createUnionShape = () => ({ kind: "union" });
+const createNullShape = () => ({ kind: "null" });
+const createArrayShape = (element) => ({
+  kind: "array",
+  element
+});
+const createRecordShape = (value) => ({
+  kind: "record",
+  value
+});
+const createTupleShape = (values) => ({
+  kind: "tuple",
+  values
+});
+function isTerminalValueShape(shape) {
+  switch (shape.kind) {
+    case "any":
+    case "string":
+    case "boolean":
+    case "number":
+    case "bytes":
+    case "date":
+    case "stringLiteral":
+    case "numberLiteral":
+    case "booleanLiteral":
+    case "enum":
+    case "union":
+    case "null":
+      return true;
+    case "deferred":
+    case "array":
+    case "record":
+    case "tuple":
+      return false;
+    default:
+      return assertNeverShape(shape);
+  }
+}
+function assertNeverShape(shape) {
+  throw new Error(`Unhandled value shape: ${String(shape)}`);
+}
+function resolveModelShape(shape, value, valueKeyedBy = "js") {
+  let current = shape;
+  const seen = /* @__PURE__ */ new Set();
+  while (current !== void 0) {
+    if (seen.has(current)) return void 0;
+    seen.add(current);
+    if (current.kind === "deferred") {
+      current = current.value();
+      continue;
+    }
+    if (current.kind === "flatModel") return current;
+    const group = current;
+    const names = group.discriminator;
+    const key = value?.[valueKeyedBy === "js" ? names.jsName : names.armName];
+    const next = typeof key === "string" ? group.byValue[key] : void 0;
+    if (next === void 0) {
+      return value ? selectVariant(group, value, valueKeyedBy) : void 0;
+    }
+    current = next;
+  }
+  return void 0;
+}
+function selectVariant(group, value, valueKeyedBy) {
+  let best;
+  let bestScore = -1;
+  for (const variant of flattenVariants(group, /* @__PURE__ */ new Set())) {
+    const score = scoreShape(variant, value, valueKeyedBy, /* @__PURE__ */ new WeakSet());
+    if (score > bestScore) {
+      bestScore = score;
+      best = variant;
+    }
+  }
+  return best;
+}
+function scoreShape(shape, value, valueKeyedBy, visiting) {
+  if (visiting.has(value)) return 0;
+  visiting.add(value);
+  const byKey = getShapePropertiesMap(shape, valueKeyedBy);
+  let score = 0;
+  for (const [key, sub] of Object.entries(value)) {
+    const prop = byKey.get(key);
+    if (!prop) continue;
+    score += 1;
+    score += scoreNested(sub, prop.value, valueKeyedBy, visiting);
+  }
+  visiting.delete(value);
+  return score;
+}
+function scoreNested(value, target, valueKeyedBy, visiting) {
+  if (!target || isTerminalValueShape(target) || value === null || typeof value !== "object") {
+    return 0;
+  }
+  if (target.kind === "array") {
+    if (!Array.isArray(value) || value.length === 0) return 0;
+    return scoreNested(value[0], target.element, valueKeyedBy, visiting);
+  }
+  if (target.kind === "record") {
+    if (Array.isArray(value)) return 0;
+    const first = Object.values(value)[0];
+    if (first === void 0) return 0;
+    return scoreNested(first, target.value, valueKeyedBy, visiting);
+  }
+  if (target.kind === "tuple") {
+    if (!Array.isArray(value)) return 0;
+    return target.values.reduce(
+      (score, tupleValue, index) => score + scoreNested(value[index], tupleValue, valueKeyedBy, visiting),
+      0
+    );
+  }
+  if (Array.isArray(value)) return 0;
+  const nested = resolveModelShape(target.value(), value, valueKeyedBy);
+  if (!nested) return 0;
+  return scoreShape(nested, value, valueKeyedBy, visiting);
+}
+const shapePropertiesCache = /* @__PURE__ */ new WeakMap();
+function getShapePropertiesMap(shape, keyedBy) {
+  let byNaming = shapePropertiesCache.get(shape);
+  if (!byNaming) {
+    byNaming = /* @__PURE__ */ new Map();
+    shapePropertiesCache.set(shape, byNaming);
+  }
+  let byKey = byNaming.get(keyedBy);
+  if (byKey) return byKey;
+  byKey = /* @__PURE__ */ new Map();
+  for (const [jsName, prop] of Object.entries(shape.byJsName)) {
+    const key = keyedBy === "js" ? jsName : prop.armPath[0];
+    if (key !== void 0 && !byKey.has(key)) byKey.set(key, prop);
+  }
+  byNaming.set(keyedBy, byKey);
+  return byKey;
+}
+function flattenVariants(group, seen) {
+  if (seen.has(group)) return [];
+  seen.add(group);
+  const out = [];
+  for (const key of Object.keys(group.byValue)) {
+    let entry = group.byValue[key];
+    if (entry?.kind === "deferred") entry = entry.value();
+    if (entry === void 0) continue;
+    if (entry.kind === "flatModel") out.push(entry);
+    else out.push(...flattenVariants(entry, seen));
+  }
+  return out;
+}
+function navigateShape(nav, segment, value) {
+  if (typeof segment === "number") {
+    return { stamp: void 0, next: peelContainer(nav, segment) };
+  }
+  if (isModelShape(nav)) {
+    const flat = resolveModelShape(nav, asRecord(value));
+    const stamp = flat?.byJsName[segment];
+    if (!stamp) return { stamp: void 0, next: void 0 };
+    return { stamp, next: derefTarget(stamp.value) };
+  }
+  if (nav && nav.kind === "record") {
+    return { stamp: void 0, next: derefTarget(nav.value) };
+  }
+  return { stamp: void 0, next: void 0 };
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function isModelShape(nav) {
+  return nav !== void 0 && (nav.kind === "flatModel" || nav.kind === "discriminatedModel");
+}
+function peelContainer(nav, index) {
+  if (!nav || isModelShape(nav)) return void 0;
+  if (nav.kind === "array") return derefTarget(nav.element);
+  if (nav.kind === "record") return derefTarget(nav.value);
+  return derefTarget(nav.values[index]);
+}
+function derefTarget(shape) {
+  if (!shape || isTerminalValueShape(shape)) return void 0;
+  if (shape.kind === "deferred") return shape.value();
+  return shape;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAnyShape,
+  createArrayShape,
+  createBooleanLiteralShape,
+  createBooleanShape,
+  createBytesShape,
+  createDateShape,
+  createDeferredShape,
+  createDiscriminatedModelShape,
+  createEnumShape,
+  createFlatModelShape,
+  createNullShape,
+  createNumberLiteralShape,
+  createNumberShape,
+  createRecordShape,
+  createStringLiteralShape,
+  createStringShape,
+  createTupleShape,
+  createUnionShape,
+  isTerminalValueShape,
+  navigateShape,
+  resolveModelShape
+});
+//# sourceMappingURL=shape.js.map

package/dist/commonjs/shape/shape.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/shape/shape.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n/**\n * Runtime types for ARM shape information.\n *\n * A `ModelShape` is generated once per emitted Model and describes how\n * to map JS-ergonomic property names + structure to the underlying ARM\n * wire shape. The shapes are consumed by the serialization `lowerState`\n * pass (and its inverse `raiseState`) which rewrites state keys and\n * re-nests `@flattenProperty` paths just before serialization /\n * after deserialization.\n *\n * These types are an internal cross-package runtime contract; generated code\n * imports them from `@azure/provisioning-core/internal`.\n *\n * Nested-shape thunks ({@link DeferredShape}) defer dereferencing the\n * inner shape constant until use, so mutually-referential or\n * self-referential models can be emitted without initialization-order\n * problems.\n *\n * A model shape comes in two flavors:\n *   - `FlatModelShape` ({@link FlatModelShape}): the common case \u2014\n *     one shape per concrete model.\n *   - `DiscriminatedModelShape` ({@link DiscriminatedModelShape}): a\n *     name-discriminated variant group. ARM permits multiple resources\n *     to share an ARM `type` + `apiVersion` pair and disambiguate via a\n *     fixed field \u2014 e.g. `Microsoft.ApiManagement/service/portalsettings@2024-05-01`\n *     has three variants with `name: 'signin' | 'signup' | 'delegation'`\n *     and distinct `properties` shapes. The same machinery applies to\n *     nested models that use a `@discriminator` field.\n */\nimport type {\n  BooleanValueEncodingDescriptor,\n  BytesValueEncodingDescriptor,\n  DateValueEncodingDescriptor,\n  NumberValueEncodingDescriptor,\n  NumericStringEncodingDescriptor,\n  StringValueEncodingDescriptor,\n} from \"./value-encoding.js\";\n\n/** The standard single-model shape. */\nexport interface FlatModelShape {\n  /**\n   * Tag for tag-dispatched discrimination on {@link NavShape} and\n   * {@link ModelShape}. Always `\"flatModel\"`.\n   */\n  readonly kind: \"flatModel\";\n  /**\n   * Map, keyed by JS-side (client-facing) property name, of how that\n   * property maps to the ARM wire shape. Property names not present in\n   * this map are assumed to be pass-through (identity mapping).\n   */\n  readonly byJsName: { readonly [jsName: string]: PropertyShape };\n}\n\n/**\n * The two names a discriminator field goes by.\n *\n * Usually identical \u2014 ARM discriminators are `type`, `name`, `kind` and\n * service teams rarely rename them \u2014 but a `@clientName` on the field\n * makes them differ, and the two are looked up in different keyspaces:\n * JS-side state is keyed by {@link jsName}, wire JSON by\n * {@link armName}. Carrying both is what lets a discriminated shape\n * resolve in either direction.\n */\nexport interface DiscriminatorNames {\n  /** Client-facing name, as authored in TypeScript and held in state. */\n  readonly jsName: string;\n  /** Wire-level name, as it appears in an ARM template or response. */\n  readonly armName: string;\n}\n\n/**\n * A name-discriminated group of variants that share one parent key\n * (an ARM `(type, apiVersion)` at the registry level, or a parent\n * model's `@discriminator` field elsewhere). The `discriminator` names\n * the field whose value selects a variant.\n */\nexport interface DiscriminatedModelShape {\n  readonly kind: \"discriminatedModel\";\n  /** Names of the field used to select a variant. */\n  readonly discriminator: DiscriminatorNames;\n  /**\n   * Map from discriminator value (e.g. `\"signin\"`) to the shape for\n   * that variant. A value with no entry here doesn't end resolution \u2014\n   * {@link resolveModelShape} infers the variant from the payload's\n   * structure instead.\n   *\n   * Entries may be:\n   *  - a {@link FlatModelShape} \u2014 the terminal, common case;\n   *  - a {@link DeferredShape} \u2014 breaks emit-order / cyclic-reference\n   *    hazards, exactly as {@link PropertyShape.value} does;\n   *  - a nested {@link DiscriminatedModelShape} \u2014 a variant that is\n   *    itself a discriminated base on a *different* field. TypeSpec\n   *    permits this (`@discriminator(\"kind\") model Pet`, then\n   *    `@discriminator(\"breed\") model Cat extends Pet`), so selecting\n   *    a concrete shape may take more than one hop. See\n   *    {@link resolveModelShape}.\n   *\n   * Note that a hierarchy re-using the *same* discriminator field at\n   * every level (abstract intermediates) is flattened by the emitter\n   * into a single level here \u2014 only a change of discriminator field\n   * produces a nested entry.\n   */\n  readonly byValue: {\n    readonly [value: string]: ModelShape | DeferredShape<ModelShape>;\n  };\n}\n\n/** A single model's shape \u2014 either flat or discriminated. */\nexport type ModelShape = FlatModelShape | DiscriminatedModelShape;\n\n/**\n * What `registerShape` stores in the global registry, keyed by\n * `(armType, apiVersion)`. Same structural type as {@link ModelShape};\n * the alias documents intent at the registry boundary.\n */\nexport type ResourceShape = ModelShape;\n\n/** A single property's shape entry. */\nexport interface PropertyShape {\n  /**\n   * ARM wire path from the owning model's root to this property.\n   * Single-segment for direct properties; multi-segment for properties\n   * hoisted through one or more `@flattenProperty` wrappers.\n   */\n  readonly armPath: readonly string[];\n\n  /**\n   * Describes this property's value for navigation and wire conversion.\n   * Model and container shapes recurse into nested values; a\n   * {@link TerminalValueShape} explicitly terminates recursion. Scalar\n   * terminal shapes carry only the encodings valid for their client-side\n   * JavaScript representation.\n   */\n  readonly value: ValueShape;\n\n  /**\n   * `true` when ARM treats this property as server-set (visible in GET\n   * responses but rejected on PUT). Omitted (i.e. `undefined`/`false`)\n   * for writable properties.\n   *\n   * Currently consumed by the `Resource` constructor's deployment-context\n   * inheritance to skip readonly properties (notably `location` on many\n   * child resources where the field exists in the read model only).\n   */\n  readonly readOnly?: boolean;\n}\n\n/**\n * Deferred reference to a shape value. The thunk is called on\n * dereference so the actual shape lookup is deferred.\n *\n * **Why this exists instead of embedding the shape directly.**\n *\n * Model shapes frequently reference each other \u2014 a model's properties\n * can point to other models, and ARM types include both self-\n * referential (tree-like) and mutually-referential (cyclic) structures.\n * If we embedded a {@link ModelShape} value directly inside another\n * model shape's value field, both shapes would need to be fully\n * initialized when the parent is constructed. That's impossible\n * whenever:\n *\n *   - A model references itself, e.g. `TreeNode { children: TreeNode[] }`.\n *   - Two models reference each other, e.g. `A { b?: B }` and `B { a?: A }`.\n *   - Two modules each define shapes that reference shapes from the other.\n *\n * In all three cases the second constant is in the Temporal Dead Zone\n * when the first one's literal evaluates, and the runtime throws\n * `ReferenceError: Cannot access ... before initialization`.\n *\n * Wrapping the reference in a thunk solves it. The closure captures\n * the *binding name*, not its current value. The lookup happens later\n * when the thunk is called \u2014 by which time the module graph has\n * finished evaluating and both shapes are fully constructed.\n *\n * Only the model variant of {@link ValueShape} carries a reference \u2014\n * container shapes (`array`, `record`) are eager because they don't\n * reference any module-level binding directly; the inner reference\n * deeper down handles cycle-breaking.\n */\nexport interface DeferredShape<T> {\n  readonly kind: \"deferred\";\n  readonly value: () => T;\n}\n\n/** An array-of-T property/container shape. */\nexport interface ArrayShape {\n  readonly kind: \"array\";\n  readonly element: ValueShape;\n}\n\n/** A `Record<string, T>` property/container shape. */\nexport interface RecordShape {\n  readonly kind: \"record\";\n  readonly value: ValueShape;\n}\n\n/** A fixed-length heterogeneous tuple property/container shape. */\nexport interface TupleShape {\n  readonly kind: \"tuple\";\n  readonly values: readonly ValueShape[];\n}\n\n/** A TypeSpec scalar rendered as TypeScript `any`. */\nexport interface AnyShape {\n  readonly kind: \"any\";\n}\n\n/** A scalar whose client-side JavaScript representation is `string`. */\nexport interface StringShape {\n  readonly kind: \"string\";\n  readonly encoding?: StringValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `boolean`. */\nexport interface BooleanShape {\n  readonly kind: \"boolean\";\n  readonly encoding?: BooleanValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `number`. */\nexport interface NumberShape {\n  readonly kind: \"number\";\n  readonly encoding?: NumberValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `Uint8Array`. */\nexport interface BytesShape {\n  readonly kind: \"bytes\";\n  readonly encoding?: BytesValueEncodingDescriptor;\n}\n\n/** A scalar whose client-side JavaScript representation is `Date`. */\nexport interface DateShape {\n  readonly kind: \"date\";\n  readonly encoding?: DateValueEncodingDescriptor;\n}\n\n/** A terminal TypeSpec string literal. Literals cannot carry `@encode`. */\nexport interface StringLiteralShape {\n  readonly kind: \"stringLiteral\";\n}\n\n/** A terminal TypeSpec numeric literal. */\nexport interface NumberLiteralShape {\n  readonly kind: \"numberLiteral\";\n  /** `@encode(string)` when the numeric literal is exposed as wire text. */\n  readonly encoding?: NumericStringEncodingDescriptor;\n}\n\n/** A terminal TypeSpec boolean literal. */\nexport interface BooleanLiteralShape {\n  readonly kind: \"booleanLiteral\";\n  /** `@encode(string)` while the client value remains a boolean literal. */\n  readonly encoding?: BooleanValueEncodingDescriptor;\n}\n\n/** A terminal TypeSpec enum. Enums cannot carry `@encode`. */\nexport interface EnumShape {\n  readonly kind: \"enum\";\n}\n\n/**\n * A terminal TypeSpec union for which no single structural shape can be\n * selected. Unions cannot carry `@encode` in the provisioning emitter.\n */\nexport interface UnionShape {\n  readonly kind: \"union\";\n}\n\n/** The TypeSpec `null` intrinsic. */\nexport interface NullShape {\n  readonly kind: \"null\";\n}\n\n/**\n * Concrete terminal values in the generated client API.\n *\n * Scalar kinds describe the JavaScript value accepted by the generated\n * TypeScript surface, not necessarily the semantic TypeSpec scalar. For\n * example, a numeric `duration` is a {@link NumberShape}, while the default\n * ISO8601 duration is a {@link StringShape}; their narrowed `encoding` fields\n * retain the TypeSpec source semantics needed for wire conversion. Numeric and\n * boolean literal shapes can carry the same narrowly applicable encodings that\n * TypeSpec permits on those values. String literals, enums, unions, and null\n * remain distinct non-encodable terminal categories.\n * Expressions are orthogonal wrappers around any value shape and are handled\n * before shape-directed conversion.\n */\nexport type TerminalValueShape =\n  | AnyShape\n  | StringShape\n  | BooleanShape\n  | NumberShape\n  | BytesShape\n  | DateShape\n  | StringLiteralShape\n  | NumberLiteralShape\n  | BooleanLiteralShape\n  | EnumShape\n  | UnionShape\n  | NullShape;\n\n/** A container through which property navigation can continue. */\nexport type ContainerShape = ArrayShape | RecordShape | TupleShape;\n\nexport type ValueShape = TerminalValueShape | DeferredShape<ModelShape> | ContainerShape;\n\n// ---------------------------------------------------------------------------\n// Constructor helpers\n// ---------------------------------------------------------------------------\n\n/** Build a {@link FlatModelShape} from a property map. */\nexport const createFlatModelShape = (byJsName: Record<string, PropertyShape>): FlatModelShape => ({\n  kind: \"flatModel\",\n  byJsName,\n});\n\n/**\n * Build a {@link DiscriminatedModelShape}.\n *\n * Pass a bare string when the field goes by the same name on both\n * sides, which is the overwhelmingly common case; pass a\n * {@link DiscriminatorNames} pair when a `@clientName` makes them\n * differ.\n */\nexport const createDiscriminatedModelShape = (\n  discriminator: string | DiscriminatorNames,\n  byValue: Record<string, ModelShape | DeferredShape<ModelShape>>,\n): DiscriminatedModelShape => ({\n  kind: \"discriminatedModel\",\n  discriminator:\n    typeof discriminator === \"string\"\n      ? { jsName: discriminator, armName: discriminator }\n      : discriminator,\n  byValue,\n});\n\n/**\n * Build a {@link DeferredShape}. The thunk is called on dereference; defer\n * the actual shape lookup so that mutually-referential constants can\n * be emitted in any order.\n */\nexport const createDeferredShape = <T>(value: () => T): DeferredShape<T> => ({\n  kind: \"deferred\",\n  value,\n});\n\n/** Build an {@link AnyShape}. */\nexport const createAnyShape = (): AnyShape => ({ kind: \"any\" });\n\n/** Build a {@link StringShape}, optionally with a compatible wire encoding. */\nexport const createStringShape = (encoding?: StringValueEncodingDescriptor): StringShape => ({\n  kind: \"string\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link BooleanShape}, optionally with a compatible wire encoding. */\nexport const createBooleanShape = (encoding?: BooleanValueEncodingDescriptor): BooleanShape => ({\n  kind: \"boolean\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link NumberShape}, optionally with a compatible wire encoding. */\nexport const createNumberShape = (encoding?: NumberValueEncodingDescriptor): NumberShape => ({\n  kind: \"number\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link BytesShape}, optionally with a compatible wire encoding. */\nexport const createBytesShape = (encoding?: BytesValueEncodingDescriptor): BytesShape => ({\n  kind: \"bytes\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a {@link DateShape}, optionally with a compatible wire encoding. */\nexport const createDateShape = (encoding?: DateValueEncodingDescriptor): DateShape => ({\n  kind: \"date\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a terminal {@link StringLiteralShape}. */\nexport const createStringLiteralShape = (): StringLiteralShape => ({\n  kind: \"stringLiteral\",\n});\n\n/** Build a terminal {@link NumberLiteralShape}. */\nexport const createNumberLiteralShape = (\n  encoding?: NumericStringEncodingDescriptor,\n): NumberLiteralShape => ({\n  kind: \"numberLiteral\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a terminal {@link BooleanLiteralShape}. */\nexport const createBooleanLiteralShape = (\n  encoding?: BooleanValueEncodingDescriptor,\n): BooleanLiteralShape => ({\n  kind: \"booleanLiteral\",\n  ...(encoding ? { encoding } : {}),\n});\n\n/** Build a terminal {@link EnumShape}. */\nexport const createEnumShape = (): EnumShape => ({ kind: \"enum\" });\n\n/** Build a terminal {@link UnionShape}. */\nexport const createUnionShape = (): UnionShape => ({ kind: \"union\" });\n\n/** Build a terminal {@link NullShape}. */\nexport const createNullShape = (): NullShape => ({ kind: \"null\" });\n\n/** Build an {@link ArrayShape}. */\nexport const createArrayShape = (element: ValueShape): ArrayShape => ({\n  kind: \"array\",\n  element,\n});\n\n/** Build a {@link RecordShape}. */\nexport const createRecordShape = (value: ValueShape): RecordShape => ({\n  kind: \"record\",\n  value,\n});\n\n/** Build a {@link TupleShape}. */\nexport const createTupleShape = (values: readonly ValueShape[]): TupleShape => ({\n  kind: \"tuple\",\n  values,\n});\n\n/** Return whether a value shape terminates property navigation. */\nexport function isTerminalValueShape(shape: ValueShape): shape is TerminalValueShape {\n  switch (shape.kind) {\n    case \"any\":\n    case \"string\":\n    case \"boolean\":\n    case \"number\":\n    case \"bytes\":\n    case \"date\":\n    case \"stringLiteral\":\n    case \"numberLiteral\":\n    case \"booleanLiteral\":\n    case \"enum\":\n    case \"union\":\n    case \"null\":\n      return true;\n    case \"deferred\":\n    case \"array\":\n    case \"record\":\n    case \"tuple\":\n      return false;\n    default:\n      return assertNeverShape(shape);\n  }\n}\n\nfunction assertNeverShape(shape: never): never {\n  throw new Error(`Unhandled value shape: ${String(shape)}`);\n}\n\n// ---------------------------------------------------------------------------\n// Helpers used by the runtime proxy + lowering pass\n// ---------------------------------------------------------------------------\n\n/**\n * Runtime navigation position for a typed proxy. Either:\n *   - a {@link ModelShape} \u2014 we're at a model's properties, whether or\n *     not its variant is known,\n *   - a {@link ContainerShape} \u2014 we're at a container that hasn't yet been\n *     indexed,\n *   - `undefined` \u2014 the current position is terminal, unknown, or the proxy\n *     was created without a shape.\n *\n * Proxies carry a `NavShape` through each access so they can stamp and\n * resolve the correct shape on deeper navigation.\n *\n * Navigation never sits at a {@link DeferredShape} \u2014 refs are resolved\n * eagerly as soon as the proxy encounters them.\n */\nexport type NavShape = ModelShape | ContainerShape | undefined;\n\n/**\n * Resolve a {@link ModelShape} to the single concrete variant that\n * applies to `value`.\n *\n * Resolution is iterative, not a single step, because a variant may\n * itself be a discriminated group keyed on a *different* field (see\n * {@link DiscriminatedModelShape.byValue}). Each hop reads its own\n * discriminator out of the same `value`, so\n * `{ kind: \"cat\", breed: \"siamese\" }` resolves through `Pet` \u2192 `Cat`\n * \u2192 `Siamese`. {@link DeferredShape} entries are dereferenced in\n * place, and flat model shapes are returned as-is.\n *\n * When a hop's discriminator can't be read \u2014 it is absent, is not a\n * string (the *expression-valued* case), or names an unknown variant \u2014\n * the variant is instead **inferred from the value's structure** by\n * {@link selectVariant}. That inference is sound rather than a guess:\n * ARM would reject a payload that doesn't match the variant its\n * discriminator selects, so a concrete payload determines the variant\n * even when the discriminator itself is only known at deploy time.\n *\n * Bicep takes the same position \u2014 a discriminator it can't evaluate at\n * compile time downgrades type checking for that object (diagnostic\n * `BCP225`) rather than failing the build.\n *\n * Returns `undefined` when `shape` is `undefined`, when there is no\n * `value` to infer from, or when the `byValue` graph is cyclic\n * (defensive; the emitter does not produce cycles here).\n *\n * @param shape - The shape to resolve. Flat shapes are returned\n *   unchanged, so callers can pass either kind without checking.\n * @param value - The object this shape describes, used both to read\n *   discriminators and to infer a variant when they can't be read.\n *   Omit it when no value exists (an `Expression<T>` proxy, say) and\n *   discriminated shapes will resolve to `undefined`.\n * @param valueKeyedBy - Which naming **`value`'s own keys** use \u2014 not\n *   the shape's. A {@link FlatModelShape} is the mapping *between* the\n *   two sides (one property is `secretVersion` in TypeScript and\n *   `version` on the wire), so inference has to read both sides in the\n *   same naming or nothing matches:\n *\n *   - `\"js\"` \u2014 client-facing names, as authored in TypeScript and held\n *     in a resource's state. These are\n *     {@link FlatModelShape.byJsName}'s own keys. Passed by\n *     `lowerState`, on state about to be serialized.\n *   - `\"arm\"` \u2014 wire names, as they appear in an ARM template or a\n *     service response. These are the first segment of each\n *     {@link PropertyShape.armPath}. Passed by `raiseState`, on JSON\n *     just parsed off the wire.\n *\n *   Has no effect when the discriminator resolves normally, and no\n *   effect at all for models whose properties map 1:1.\n */\nexport function resolveModelShape(\n  shape: ModelShape | undefined,\n  value: Record<string, unknown> | undefined,\n  valueKeyedBy: \"js\" | \"arm\" = \"js\",\n): FlatModelShape | undefined {\n  let current: ModelShape | DeferredShape<ModelShape> | undefined = shape;\n  const seen = new Set<ModelShape | DeferredShape<ModelShape>>();\n\n  while (current !== undefined) {\n    if (seen.has(current)) return undefined;\n    seen.add(current);\n\n    if (current.kind === \"deferred\") {\n      current = current.value();\n      continue;\n    }\n    if (current.kind === \"flatModel\") return current;\n\n    const group: DiscriminatedModelShape = current;\n    // Read the discriminator under the same naming as `value`'s own\n    // keys: JS-side state holds it under the client name, wire JSON\n    // under the ARM name. The two coincide for almost every ARM\n    // discriminator, but a `@clientName` on the field makes them\n    // differ, and reading the wrong one silently downgrades exact\n    // dispatch to structural inference below.\n    const names = group.discriminator;\n    const key = value?.[valueKeyedBy === \"js\" ? names.jsName : names.armName];\n    const next = typeof key === \"string\" ? group.byValue[key] : undefined;\n    if (next === undefined) {\n      return value ? selectVariant(group, value, valueKeyedBy) : undefined;\n    }\n    current = next;\n  }\n\n  return undefined;\n}\n\n/**\n * Infer which variant of `group` a value belongs to by structure.\n *\n * Every variant is scored by how many of the value's keys it declares,\n * descending into nested objects and containers so that variants which\n * are indistinguishable at the top level can still be told apart. CDN's\n * delivery-rule actions are exactly that case: all nine variants\n * declare `{ name, parameters }` and differ only inside `parameters`.\n *\n * The highest score wins; ties keep the earliest variant in `byValue`\n * order, which is stable emitter output. A tie means the tied variants\n * declare the same keys for the data given, and the emitter guarantees\n * that keys shared across variants map identically \u2014 so either choice\n * produces the same wire mapping for everything actually present.\n */\nfunction selectVariant(\n  group: DiscriminatedModelShape,\n  value: Record<string, unknown>,\n  valueKeyedBy: \"js\" | \"arm\",\n): FlatModelShape | undefined {\n  let best: FlatModelShape | undefined;\n  let bestScore = -1;\n\n  for (const variant of flattenVariants(group, new Set())) {\n    const score = scoreShape(variant, value, valueKeyedBy, new WeakSet());\n    if (score > bestScore) {\n      bestScore = score;\n      best = variant;\n    }\n  }\n\n  return best;\n}\n\n/** How many of `value`'s keys, recursively, `shape` accounts for. */\nfunction scoreShape(\n  shape: FlatModelShape,\n  value: Record<string, unknown>,\n  valueKeyedBy: \"js\" | \"arm\",\n  visiting: WeakSet<object>,\n): number {\n  if (visiting.has(value)) return 0;\n  visiting.add(value);\n\n  const byKey = getShapePropertiesMap(shape, valueKeyedBy);\n  let score = 0;\n\n  for (const [key, sub] of Object.entries(value)) {\n    const prop = byKey.get(key);\n    if (!prop) continue;\n    score += 1;\n    score += scoreNested(sub, prop.value, valueKeyedBy, visiting);\n  }\n\n  visiting.delete(value);\n  return score;\n}\n\n/**\n * Score one level deeper, through a property's target. Containers are\n * sampled at their first entry \u2014 enough to discriminate, and bounded\n * regardless of how large the value is.\n */\nfunction scoreNested(\n  value: unknown,\n  target: ValueShape | undefined,\n  valueKeyedBy: \"js\" | \"arm\",\n  visiting: WeakSet<object>,\n): number {\n  if (!target || isTerminalValueShape(target) || value === null || typeof value !== \"object\") {\n    return 0;\n  }\n\n  if (target.kind === \"array\") {\n    if (!Array.isArray(value) || value.length === 0) return 0;\n    return scoreNested(value[0], target.element, valueKeyedBy, visiting);\n  }\n\n  if (target.kind === \"record\") {\n    if (Array.isArray(value)) return 0;\n    const first = Object.values(value)[0];\n    if (first === undefined) return 0;\n    return scoreNested(first, target.value, valueKeyedBy, visiting);\n  }\n\n  if (target.kind === \"tuple\") {\n    if (!Array.isArray(value)) return 0;\n    return target.values.reduce(\n      (score, tupleValue, index) =>\n        score + scoreNested(value[index], tupleValue, valueKeyedBy, visiting),\n      0,\n    );\n  }\n\n  if (Array.isArray(value)) return 0;\n  const nested = resolveModelShape(target.value(), value as Record<string, unknown>, valueKeyedBy);\n  if (!nested) return 0;\n  return scoreShape(nested, value as Record<string, unknown>, valueKeyedBy, visiting);\n}\n\nconst shapePropertiesCache = new WeakMap<\n  FlatModelShape,\n  Map<\"js\" | \"arm\", Map<string, PropertyShape>>\n>();\n\n/**\n * A shape's properties as a map, keyed by the name they go by in the\n * requested naming. Pass the same naming the value uses and the two\n * line up, which is what lets {@link scoreShape} compare them.\n *\n * Memoized per (shape, naming): scoring calls this once per candidate\n * variant per level, so rebuilding would be wasteful.\n *\n * @param shape - The shape whose properties to map.\n * @param keyedBy - Which name to key by. Note this describes the *map\n *   being built*, not an incoming value \u2014 unlike the `valueKeyedBy`\n *   parameter the callers thread through.\n */\nfunction getShapePropertiesMap(\n  shape: FlatModelShape,\n  keyedBy: \"js\" | \"arm\",\n): Map<string, PropertyShape> {\n  let byNaming = shapePropertiesCache.get(shape);\n  if (!byNaming) {\n    byNaming = new Map();\n    shapePropertiesCache.set(shape, byNaming);\n  }\n  let byKey = byNaming.get(keyedBy);\n  if (byKey) return byKey;\n\n  byKey = new Map<string, PropertyShape>();\n  for (const [jsName, prop] of Object.entries(shape.byJsName)) {\n    // `armPath[0]` rather than the whole path: that is the top-level\n    // wire key, even for properties hoisted through `@flattenProperty`.\n    const key = keyedBy === \"js\" ? jsName : prop.armPath[0];\n    // First writer wins, so a hoisted property never shadows the\n    // wrapper it was hoisted through.\n    if (key !== undefined && !byKey.has(key)) byKey.set(key, prop);\n  }\n  byNaming.set(keyedBy, byKey);\n  return byKey;\n}\n\n/**\n * Flatten a group to the concrete flat shapes underneath it,\n * dereferencing thunks and descending through nested groups.\n */\nfunction flattenVariants(\n  group: DiscriminatedModelShape,\n  seen: Set<DiscriminatedModelShape>,\n): FlatModelShape[] {\n  if (seen.has(group)) return [];\n  seen.add(group);\n\n  const out: FlatModelShape[] = [];\n  for (const key of Object.keys(group.byValue)) {\n    let entry: ModelShape | DeferredShape<ModelShape> | undefined = group.byValue[key];\n    if (entry?.kind === \"deferred\") entry = entry.value();\n    if (entry === undefined) continue;\n    if (entry.kind === \"flatModel\") out.push(entry);\n    else out.push(...flattenVariants(entry, seen));\n  }\n  return out;\n}\n\n/**\n * Navigate `nav` one step deeper using `segment`. For string segments\n * (`.foo`) at a model position, returns the property's shape entry as\n * `stamp` and advances `next` into the property's target. For numeric\n * segments (`[i]`) or string keys at a record position, peels one\n * container layer; `stamp` is always `undefined`.\n *\n * Returns `{ stamp: undefined, next: undefined }` when the step can't\n * be resolved (unknown property, out-of-shape access, etc.) \u2014 the\n * access is treated as passthrough.\n *\n * @param nav - Where navigation currently sits.\n * @param segment - The member name or array index being accessed.\n * @param value - The value sitting at `nav`, when the caller has one.\n *   Consulted only at a {@link DiscriminatedModelShape} position, to\n *   select the variant via {@link resolveModelShape}. Always read with\n *   `\"js\"` naming, since navigation follows client-facing property\n *   names. Callers with no value \u2014 an `Expression<T>` proxy, for\n *   instance \u2014 omit it and get passthrough for discriminated\n *   positions, which is the honest answer when the variant is\n *   unknowable.\n */\nexport function navigateShape(\n  nav: NavShape,\n  segment: string | number,\n  value?: unknown,\n): { readonly stamp: PropertyShape | undefined; readonly next: NavShape } {\n  if (typeof segment === \"number\") {\n    return { stamp: undefined, next: peelContainer(nav, segment) };\n  }\n  if (isModelShape(nav)) {\n    const flat = resolveModelShape(nav, asRecord(value));\n    const stamp = flat?.byJsName[segment];\n    if (!stamp) return { stamp: undefined, next: undefined };\n    return { stamp, next: derefTarget(stamp.value) };\n  }\n  // String segment against a container \u2014 treat as a record key access.\n  if (nav && nav.kind === \"record\") {\n    return { stamp: undefined, next: derefTarget(nav.value) };\n  }\n  return { stamp: undefined, next: undefined };\n}\n\nfunction asRecord(value: unknown): Record<string, unknown> | undefined {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\nfunction isModelShape(nav: NavShape): nav is ModelShape {\n  return nav !== undefined && (nav.kind === \"flatModel\" || nav.kind === \"discriminatedModel\");\n}\n\n/**\n * Peel one container layer off `nav`. Returns `undefined` for\n * non-containers (caller treats the step as passthrough).\n */\nfunction peelContainer(nav: NavShape, index: number): NavShape {\n  if (!nav || isModelShape(nav)) return undefined;\n  if (nav.kind === \"array\") return derefTarget(nav.element);\n  if (nav.kind === \"record\") return derefTarget(nav.value);\n  return derefTarget(nav.values[index]);\n}\n\n/**\n * Convert a {@link ValueShape} \u2014 where a property *points* \u2014 into a\n * {@link NavShape} \u2014 where navigation now *is*.\n *\n * The only real work is forcing a {@link DeferredShape} thunk; the\n * resolved model becomes the new position whether or not it is\n * discriminated, since {@link navigateShape} can look up properties on\n * either. Container shapes pass through unchanged, pending an index\n * step.\n *\n * Deliberately *not* named `resolve*` \u2014 that prefix belongs to\n * {@link resolveModelShape}, which picks a variant and is a much\n * heavier operation.\n */\nfunction derefTarget(shape: ValueShape | undefined): NavShape {\n  if (!shape || isTerminalValueShape(shape)) return undefined;\n  if (shape.kind === \"deferred\") return shape.value();\n  return shape;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/commonjs/shape/value-encoding.d.ts

@@ -0,0 +1,121 @@
+export declare const INTEGER_SCALAR_NAMES: readonly ["integer", "safeint", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"];
+export type IntegerScalarName = (typeof INTEGER_SCALAR_NAMES)[number];
+export declare const NUMERIC_SCALAR_NAMES: readonly ["integer", "safeint", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64", "numeric", "decimal", "decimal128", "float", "float32", "float64"];
+export type NumericScalarName = (typeof NUMERIC_SCALAR_NAMES)[number];
+export declare function isIntegerScalarName(name: string): name is IntegerScalarName;
+export declare function isNumericScalarName(name: string): name is NumericScalarName;
+export interface DateTimeTextEncodingDescriptor {
+    readonly kind: "date-time-text";
+    readonly source: "utcDateTime" | "offsetDateTime";
+    readonly format: "rfc3339" | "rfc7231";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface UnixTimestampEncodingDescriptor {
+    readonly kind: "unix-timestamp";
+    readonly source: "utcDateTime";
+    readonly unit: "seconds";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "integer";
+        readonly scalar: IntegerScalarName;
+    };
+}
+export interface DurationIso8601EncodingDescriptor {
+    readonly kind: "duration-iso8601";
+    readonly source: "duration";
+    readonly clientMode: "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface DurationNumericEncodingDescriptor {
+    readonly kind: "duration-numeric";
+    readonly source: "duration";
+    readonly unit: "seconds" | "milliseconds";
+    readonly clientMode: "wire";
+    readonly wire: {
+        readonly kind: "integer";
+        readonly scalar: IntegerScalarName;
+    };
+}
+export interface BytesEncodingDescriptor {
+    readonly kind: "bytes";
+    readonly source: "bytes";
+    readonly format: "base64" | "base64url";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface PlainDateEncodingDescriptor {
+    readonly kind: "plain-date";
+    readonly source: "plainDate";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface NumericStringEncodingDescriptor {
+    readonly kind: "numeric-string";
+    readonly source: "integer" | "number";
+    readonly sourceScalar: NumericScalarName;
+    readonly clientMode: "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export interface BooleanStringEncodingDescriptor {
+    readonly kind: "boolean-string";
+    readonly source: "boolean";
+    readonly clientMode: "client" | "wire";
+    readonly wire: {
+        readonly kind: "string";
+    };
+}
+export type ValueEncodingDescriptor = DateTimeTextEncodingDescriptor | UnixTimestampEncodingDescriptor | DurationIso8601EncodingDescriptor | DurationNumericEncodingDescriptor | BytesEncodingDescriptor | PlainDateEncodingDescriptor | NumericStringEncodingDescriptor | BooleanStringEncodingDescriptor;
+/**
+ * Encodings whose client-side value is a JavaScript `string`.
+ *
+ * The source TypeSpec scalar can be a date/time, duration, byte sequence,
+ * numeric value, or boolean. `clientMode: "wire"` is the important invariant:
+ * it means the generated TypeScript API exposes the encoded string itself.
+ */
+export type StringValueEncodingDescriptor = (DateTimeTextEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | DurationIso8601EncodingDescriptor | (BytesEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | (PlainDateEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | NumericStringEncodingDescriptor | (BooleanStringEncodingDescriptor & {
+    readonly clientMode: "wire";
+});
+/** Encoding supported by a client-side JavaScript `boolean`. */
+export type BooleanValueEncodingDescriptor = BooleanStringEncodingDescriptor & {
+    readonly clientMode: "client";
+};
+/** Encodings whose client-side value is a JavaScript `number`. */
+export type NumberValueEncodingDescriptor = (UnixTimestampEncodingDescriptor & {
+    readonly clientMode: "wire";
+}) | DurationNumericEncodingDescriptor;
+/** Encoding supported by a client-side JavaScript `Uint8Array`. */
+export type BytesValueEncodingDescriptor = BytesEncodingDescriptor & {
+    readonly clientMode: "client";
+};
+/**
+ * Encodings whose client-side value is a JavaScript `Date`.
+ *
+ * `offsetDateTime` is intentionally absent: the emitter exposes it as a
+ * string so the original offset is not erased.
+ */
+export type DateValueEncodingDescriptor = (DateTimeTextEncodingDescriptor & {
+    readonly source: "utcDateTime";
+    readonly clientMode: "client";
+}) | (UnixTimestampEncodingDescriptor & {
+    readonly clientMode: "client";
+}) | (PlainDateEncodingDescriptor & {
+    readonly clientMode: "client";
+});
+//# sourceMappingURL=value-encoding.d.ts.map

package/dist/commonjs/shape/value-encoding.d.ts.map

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

package/dist/commonjs/shape/value-encoding.js

@@ -0,0 +1,62 @@
+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 value_encoding_exports = {};
+__export(value_encoding_exports, {
+  INTEGER_SCALAR_NAMES: () => INTEGER_SCALAR_NAMES,
+  NUMERIC_SCALAR_NAMES: () => NUMERIC_SCALAR_NAMES,
+  isIntegerScalarName: () => isIntegerScalarName,
+  isNumericScalarName: () => isNumericScalarName
+});
+module.exports = __toCommonJS(value_encoding_exports);
+const INTEGER_SCALAR_NAMES = [
+  "integer",
+  "safeint",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64"
+];
+const NUMERIC_SCALAR_NAMES = [
+  ...INTEGER_SCALAR_NAMES,
+  "numeric",
+  "decimal",
+  "decimal128",
+  "float",
+  "float32",
+  "float64"
+];
+const integerScalarNames = new Set(INTEGER_SCALAR_NAMES);
+const numericScalarNames = new Set(NUMERIC_SCALAR_NAMES);
+function isIntegerScalarName(name) {
+  return integerScalarNames.has(name);
+}
+function isNumericScalarName(name) {
+  return numericScalarNames.has(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTEGER_SCALAR_NAMES,
+  NUMERIC_SCALAR_NAMES,
+  isIntegerScalarName,
+  isNumericScalarName
+});
+//# sourceMappingURL=value-encoding.js.map

package/dist/commonjs/shape/value-encoding.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/shape/value-encoding.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nexport const INTEGER_SCALAR_NAMES = [\n  \"integer\",\n  \"safeint\",\n  \"int8\",\n  \"int16\",\n  \"int32\",\n  \"int64\",\n  \"uint8\",\n  \"uint16\",\n  \"uint32\",\n  \"uint64\",\n] as const;\n\nexport type IntegerScalarName = (typeof INTEGER_SCALAR_NAMES)[number];\n\nexport const NUMERIC_SCALAR_NAMES = [\n  ...INTEGER_SCALAR_NAMES,\n  \"numeric\",\n  \"decimal\",\n  \"decimal128\",\n  \"float\",\n  \"float32\",\n  \"float64\",\n] as const;\n\nexport type NumericScalarName = (typeof NUMERIC_SCALAR_NAMES)[number];\n\nconst integerScalarNames: ReadonlySet<string> = new Set(INTEGER_SCALAR_NAMES);\nconst numericScalarNames: ReadonlySet<string> = new Set(NUMERIC_SCALAR_NAMES);\n\nexport function isIntegerScalarName(name: string): name is IntegerScalarName {\n  return integerScalarNames.has(name);\n}\n\nexport function isNumericScalarName(name: string): name is NumericScalarName {\n  return numericScalarNames.has(name);\n}\n\nexport interface DateTimeTextEncodingDescriptor {\n  readonly kind: \"date-time-text\";\n  readonly source: \"utcDateTime\" | \"offsetDateTime\";\n  readonly format: \"rfc3339\" | \"rfc7231\";\n  readonly clientMode: \"client\" | \"wire\";\n  readonly wire: { readonly kind: \"string\" };\n}\n\nexport interface UnixTimestampEncodingDescriptor {\n  readonly kind: \"unix-timestamp\";\n  readonly source: \"utcDateTime\";\n  readonly unit: \"seconds\";\n  readonly clientMode: \"client\" | \"wire\";\n  readonly wire: {\n    readonly kind: \"integer\";\n    readonly scalar: IntegerScalarName;\n  };\n}\n\nexport interface DurationIso8601EncodingDescriptor {\n  readonly kind: \"duration-iso8601\";\n  readonly source: \"duration\";\n  readonly clientMode: \"wire\";\n  readonly wire: { readonly kind: \"string\" };\n}\n\nexport interface DurationNumericEncodingDescriptor {\n  readonly kind: \"duration-numeric\";\n  readonly source: \"duration\";\n  readonly unit: \"seconds\" | \"milliseconds\";\n  readonly clientMode: \"wire\";\n  readonly wire: {\n    readonly kind: \"integer\";\n    readonly scalar: IntegerScalarName;\n  };\n}\n\nexport interface BytesEncodingDescriptor {\n  readonly kind: \"bytes\";\n  readonly source: \"bytes\";\n  readonly format: \"base64\" | \"base64url\";\n  readonly clientMode: \"client\" | \"wire\";\n  readonly wire: { readonly kind: \"string\" };\n}\n\nexport interface PlainDateEncodingDescriptor {\n  readonly kind: \"plain-date\";\n  readonly source: \"plainDate\";\n  readonly clientMode: \"client\" | \"wire\";\n  readonly wire: { readonly kind: \"string\" };\n}\n\nexport interface NumericStringEncodingDescriptor {\n  readonly kind: \"numeric-string\";\n  readonly source: \"integer\" | \"number\";\n  readonly sourceScalar: NumericScalarName;\n  readonly clientMode: \"wire\";\n  readonly wire: { readonly kind: \"string\" };\n}\n\nexport interface BooleanStringEncodingDescriptor {\n  readonly kind: \"boolean-string\";\n  readonly source: \"boolean\";\n  readonly clientMode: \"client\" | \"wire\";\n  readonly wire: { readonly kind: \"string\" };\n}\n\nexport type ValueEncodingDescriptor =\n  | DateTimeTextEncodingDescriptor\n  | UnixTimestampEncodingDescriptor\n  | DurationIso8601EncodingDescriptor\n  | DurationNumericEncodingDescriptor\n  | BytesEncodingDescriptor\n  | PlainDateEncodingDescriptor\n  | NumericStringEncodingDescriptor\n  | BooleanStringEncodingDescriptor;\n\n/**\n * Encodings whose client-side value is a JavaScript `string`.\n *\n * The source TypeSpec scalar can be a date/time, duration, byte sequence,\n * numeric value, or boolean. `clientMode: \"wire\"` is the important invariant:\n * it means the generated TypeScript API exposes the encoded string itself.\n */\nexport type StringValueEncodingDescriptor =\n  | (DateTimeTextEncodingDescriptor & { readonly clientMode: \"wire\" })\n  | DurationIso8601EncodingDescriptor\n  | (BytesEncodingDescriptor & { readonly clientMode: \"wire\" })\n  | (PlainDateEncodingDescriptor & { readonly clientMode: \"wire\" })\n  | NumericStringEncodingDescriptor\n  | (BooleanStringEncodingDescriptor & { readonly clientMode: \"wire\" });\n\n/** Encoding supported by a client-side JavaScript `boolean`. */\nexport type BooleanValueEncodingDescriptor = BooleanStringEncodingDescriptor & {\n  readonly clientMode: \"client\";\n};\n\n/** Encodings whose client-side value is a JavaScript `number`. */\nexport type NumberValueEncodingDescriptor =\n  | (UnixTimestampEncodingDescriptor & { readonly clientMode: \"wire\" })\n  | DurationNumericEncodingDescriptor;\n\n/** Encoding supported by a client-side JavaScript `Uint8Array`. */\nexport type BytesValueEncodingDescriptor = BytesEncodingDescriptor & {\n  readonly clientMode: \"client\";\n};\n\n/**\n * Encodings whose client-side value is a JavaScript `Date`.\n *\n * `offsetDateTime` is intentionally absent: the emitter exposes it as a\n * string so the original offset is not erased.\n */\nexport type DateValueEncodingDescriptor =\n  | (DateTimeTextEncodingDescriptor & {\n      readonly source: \"utcDateTime\";\n      readonly clientMode: \"client\";\n    })\n  | (UnixTimestampEncodingDescriptor & { readonly clientMode: \"client\" })\n  | (PlainDateEncodingDescriptor & { readonly clientMode: \"client\" });\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIO,MAAM,uBAAuB;AAAA,EAClC,GAAG;AAAA,EACH;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIA,MAAM,qBAA0C,IAAI,IAAI,oBAAoB;AAC5E,MAAM,qBAA0C,IAAI,IAAI,oBAAoB;AAErE,SAAS,oBAAoB,MAAyC;AAC3E,SAAO,mBAAmB,IAAI,IAAI;AACpC;AAEO,SAAS,oBAAoB,MAAyC;AAC3E,SAAO,mBAAmB,IAAI,IAAI;AACpC;",
+  "names": []
+}

package/dist/commonjs/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.59.1"
+    }
+  ]
+}

package/dist/commonjs/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * General-purpose type aliases used across the core package.
+ *
+ * Keep this file dependency-free so it can be imported from any layer
+ * (AST, proxy, resource, shape) without introducing cycles.
+ */
+/** A single member access segment: an object property name or an array index. */
+export type PropertySegment = string | number;
+//# sourceMappingURL=types.d.ts.map

package/dist/commonjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AAEH,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC"}

package/dist/commonjs/types.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/commonjs/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/types.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n/**\n * General-purpose type aliases used across the core package.\n *\n * Keep this file dependency-free so it can be imported from any layer\n * (AST, proxy, resource, shape) without introducing cycles.\n */\n\n/** A single member access segment: an object property name or an array index. */\nexport type PropertySegment = string | number;\n"],
+  "mappings": ";;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}