@typespec/html-program-viewer 0.68.0 → 0.69.0

package/dist/react/index.js

@@ -19096,7 +19096,7 @@ const diagnostics = {
     },
     // #endregion CLI
 };
-const { createDiagnostic} = createDiagnosticCreator(diagnostics);
+const { createDiagnostic, reportDiagnostic } = createDiagnosticCreator(diagnostics);
 
 var ajv = {exports: {}};
 
@@ -28331,6 +28331,39 @@ function compilerAssert(condition, message, target) {
     }
     throw new Error(message);
 }
+/**
+ * Create a new instance of the @see DiagnosticCollector.
+ */
+function createDiagnosticCollector() {
+    const diagnostics = [];
+    return {
+        diagnostics,
+        add,
+        pipe,
+        wrap,
+        join,
+    };
+    function add(diagnostic) {
+        diagnostics.push(diagnostic);
+    }
+    function pipe(result) {
+        const [value, diags] = result;
+        for (const diag of diags) {
+            diagnostics.push(diag);
+        }
+        return value;
+    }
+    function wrap(value) {
+        return [value, diagnostics];
+    }
+    function join(result) {
+        const [value, diags] = result;
+        for (const diag of diags) {
+            diagnostics.push(diag);
+        }
+        return [value, diagnostics];
+    }
+}
 /**
  * Ignore the diagnostics emitted by the diagnostic accessor pattern and just return the actual result.
  * @param result Accessor pattern tuple result including the actual result and the list of diagnostics.
@@ -28593,6 +28626,25 @@ function defineKit(source) {
     }
 }
 
+/**
+ * Creates a diagnosable function wrapper.
+ *
+ * The returned function will ignore diagnostics by default.
+ * A `withDiagnostics` property is attached to the returned function,
+ * allowing access to the original function's return value including diagnostics.
+ *
+ * @param fn The function to wrap, which must return a tuple `[Result, readonly Diagnostic[]]`.
+ * @returns A function that ignores diagnostics by default, with a `withDiagnostics` method.
+ * @experimental
+ */
+function createDiagnosable(fn) {
+    function wrapper(...args) {
+        return ignoreDiagnostics(fn.apply(this, args));
+    }
+    wrapper.withDiagnostics = fn;
+    return wrapper;
+}
+
 function isErrorType(type) {
     return "kind" in type && type.kind === "Intrinsic" && type.name === "ErrorType";
 }
@@ -28788,7 +28840,6 @@ defineKit({
                 name: desc.name,
                 value: desc.value,
                 decorators: decoratorApplication(this, desc.decorators),
-                node: undefined,
                 enum: desc.enum, // initialized in enum.build if not provided here
             });
             this.program.checker.finishType(member);
@@ -28800,424 +28851,107 @@ defineKit({
     },
 });
 
-defineKit({
-    enum: {
-        create(desc) {
-            const en = this.program.checker.createType({
-                kind: "Enum",
-                name: desc.name,
-                decorators: decoratorApplication(this, desc.decorators),
-                members: createRekeyableMap(),
-                node: undefined,
-            });
-            if (Array.isArray(desc.members)) {
-                for (const member of desc.members) {
-                    member.enum = en;
-                    en.members.set(member.name, member);
-                }
-            }
-            else {
-                for (const [name, member] of Object.entries(desc.members ?? {})) {
-                    en.members.set(name, this.enumMember.create({ name, value: member, enum: en }));
-                }
-            }
-            this.program.checker.finishType(en);
-            return en;
-        },
-        is(type) {
-            return type.kind === "Enum";
-        },
-        createFromUnion(type) {
-            if (!type.name) {
-                throw new Error("Cannot create an enum from an anonymous union.");
-            }
-            const enumMembers = [];
-            for (const variant of type.variants.values()) {
-                if ((variant.name && typeof variant.name === "symbol") ||
-                    (!this.literal.isString(variant.type) && !this.literal.isNumeric(variant.type))) {
-                    continue;
-                }
-                enumMembers.push(this.enumMember.create({ name: variant.name, value: variant.type.value }));
-            }
-            return this.enum.create({ name: type.name, members: enumMembers });
-        },
-    },
-});
-
-class InvalidNumericError extends Error {
-    code = "InvalidNumeric";
+function isIntrinsicType(program, type, kind) {
+    return ignoreDiagnostics(program.checker.isTypeAssignableTo(type, program.checker.getStdType(kind), type));
 }
-/** @internal */
-const InternalDataSym = Symbol.for("NumericInternalData");
-/**
- * Represent any possible numeric value
- */
-function Numeric(stringValue) {
-    if (new.target) {
-        throw new Error("Numeric is not a constructor");
+function validateDecoratorUniqueOnNode(context, type, decorator) {
+    compilerAssert("decorators" in type, "Type should have decorators");
+    const sameDecorators = type.decorators.filter((x) => x.decorator === decorator &&
+        x.node?.kind === SyntaxKind.DecoratorExpression &&
+        x.node?.parent === type.node);
+    if (sameDecorators.length > 1) {
+        reportDiagnostic(context.program, {
+            code: "duplicate-decorator",
+            format: { decoratorName: "@" + decorator.name.slice(1) },
+            target: context.decoratorTarget,
+        });
+        return false;
     }
-    const data = parse(stringValue);
-    const isInteger = data.d === 0;
-    const obj = {
-        [InternalDataSym]: data,
-        isInteger,
-    };
-    // We are explicitly not using a class here due to version mismatch between the compiler and the runtime that could happen and break instanceof checks.
-    const numeric = setTypedProptotype(obj, NumericPrototype);
-    return Object.freeze(numeric);
+    return true;
 }
-function setTypedProptotype(obj, prototype) {
-    Object.setPrototypeOf(obj, prototype);
-    return obj;
+
+/**
+ * Filters the properties of a model by removing them from the model instance if
+ * a given `filter` predicate is not satisfied.
+ *
+ * @param model - the model to filter properties on
+ * @param filter - the predicate to filter properties with
+ */
+/**
+ * Creates a unique symbol for storing state on objects
+ * @param name The name/description of the state
+ */
+function createStateSymbol(name) {
+    return Symbol.for(`TypeSpec.${name}`);
 }
-function parse(original) {
-    let stringValue = original;
-    let start = 0;
-    let sign = 1;
-    let n;
-    let exp;
-    let decimal = undefined;
-    if (stringValue[0] === "-") {
-        start = 1;
-        sign = -1;
+
+const deprecatedKey = createStateSymbol("deprecated");
+/**
+ * Returns complete deprecation details for the given type or node
+ * @param program Program
+ * @param typeOrNode A Type or Node to check for deprecation
+ */
+function getDeprecationDetails(program, typeOrNode) {
+    function isType(maybeType) {
+        return typeof maybeType.kind === "string";
     }
-    const second = stringValue[start + 1]?.toLowerCase();
-    if (stringValue[start] === "0" && (second === "b" || second === "x" || second === "o")) {
-        try {
-            n = BigInt(stringValue.slice(start));
-            exp = n.toString().length;
-            decimal = 0;
-        }
-        catch {
-            throw new InvalidNumericError(`Invalid numeric value: ${original}`);
-        }
+    // If we're looking at a type, pull the deprecation details from the state map
+    if (isType(typeOrNode)) {
+        return program.stateMap(deprecatedKey).get(typeOrNode);
     }
     else {
-        // Skip leading 0.
-        while (stringValue[start] === "0") {
-            start++;
-        }
-        const decimalPointIndex = stringValue.indexOf(".");
-        const adjustedPointIndex = decimalPointIndex - start;
-        // Decimal point?
-        if (decimalPointIndex !== -1) {
-            exp = adjustedPointIndex;
-            stringValue = stringValue.replace(".", "");
-        }
-        let i;
-        if ((i = stringValue.search(/e/i)) > 0) {
-            // Determine exponent.
-            if (exp === undefined) {
-                exp = i - start;
-            }
-            exp += Number(stringValue.slice(i + 1));
-            stringValue = stringValue.slice(start, i);
-            decimal = Math.max(stringValue.length - exp, 0);
+        // Look at the node for a deprecation directive
+        const deprecatedDirective = (typeOrNode.directives ?? []).find((directive) => directive.target.sv === "deprecated");
+        if (deprecatedDirective?.arguments[0].kind === SyntaxKind.StringLiteral) {
+            return {
+                message: deprecatedDirective.arguments[0].value,
+            };
         }
-        else if (exp === undefined) {
-            // Integer.
-            exp = stringValue.length - start;
-            stringValue = stringValue.slice(start);
+    }
+    return undefined;
+}
+
+/**
+ * Helper class to track duplicate instance
+ */
+class DuplicateTracker {
+    #entries = new Map();
+    /**
+     * Track usage of K.
+     * @param k key that is being checked for duplicate.
+     * @param v value that map to the key
+     */
+    track(k, v) {
+        const existing = this.#entries.get(k);
+        if (existing === undefined) {
+            this.#entries.set(k, [v]);
         }
         else {
-            stringValue = stringValue.slice(start);
-        }
-        let end = stringValue.length;
-        while (stringValue[end - 1] === "0" && end > adjustedPointIndex) {
-            end--;
-        }
-        // Only if there is 0 before the decimal point, keeps checking how many 0 there is after it and update the exponent accordingly.
-        if (start === adjustedPointIndex + 1) {
-            let cur = adjustedPointIndex;
-            while (stringValue[cur] === "0" && cur < end) {
-                cur++;
-                exp--;
-            }
+            existing.push(v);
         }
-        try {
-            stringValue = stringValue.slice(0, end);
-            stringValue = stringValue + "0".repeat(Math.max(exp - stringValue.length, 0)); // add remaining zeros for cases like 3e30
-            n = BigInt(stringValue);
-            if (n === 0n) {
-                decimal = 0;
-            }
-            else if (decimal === undefined) {
-                decimal = Math.max(stringValue.length - Math.max(exp, 0), 0);
+    }
+    /**
+     * Return iterator of all the duplicate entries.
+     */
+    *entries() {
+        for (const [k, v] of this.#entries.entries()) {
+            if (v.length > 1) {
+                yield [k, v];
             }
         }
-        catch {
-            throw new InvalidNumericError(`Invalid numeric value: ${original}`);
-        }
     }
-    return { n, e: exp, s: sign, d: decimal };
 }
-function stringify(value) {
-    if (value.n === 0n)
-        return "0";
-    const n = value.n.toString();
-    const sign = value.s === -1 ? "-" : "";
-    const int = value.e <= 0 ? "0" : n.slice(0, value.e);
-    const decimal = value.e < n.length ? "." + n.slice(-value.d).padStart(value.d, "0") : "";
-    return sign + int + decimal;
+
+function useStateMap(key) {
+    const getter = (program, target) => program.stateMap(key).get(target);
+    const setter = (program, target, value) => program.stateMap(key).set(target, value);
+    const mapGetter = (program) => program.stateMap(key);
+    return [getter, setter, mapGetter];
 }
-const equals = (a, b) => a.n === b.n && a.e === b.e;
-const compare = (a, b) => {
-    if (a.s < b.s) {
-        return -1;
-    }
-    else if (a.s > b.s) {
-        return 1;
-    }
-    const neg = a.s;
-    if (a.e < b.e) {
-        return (-1 * neg);
-    }
-    else if (a.e > b.e) {
-        return (1 * neg);
-    }
-    let aN = a.n;
-    let bN = b.n;
-    if (a.d < b.d) {
-        aN *= 10n ** BigInt(b.d - a.d);
-    }
-    else {
-        bN *= 10n ** BigInt(a.d - b.d);
-    }
-    if (aN < bN)
-        return (-1 * neg);
-    if (aN > bN)
-        return (1 * neg);
-    return 0;
-};
-const NumericPrototype = {
-    toString: function () {
-        return stringify(this[InternalDataSym]);
-    },
-    asNumber: function () {
-        const num = Number(stringify(this[InternalDataSym]));
-        return equals(this[InternalDataSym], Numeric(num.toString())[InternalDataSym]) ? num : null;
-    },
-    asBigInt: function () {
-        if (!this.isInteger) {
-            return null;
-        }
-        const { s, n } = this[InternalDataSym];
-        return BigInt(s) * n;
-    },
-    equals: function (other) {
-        return equals(this[InternalDataSym], other[InternalDataSym]);
-    },
-    lt: function (other) {
-        return compare(this[InternalDataSym], other[InternalDataSym]) === -1;
-    },
-    lte: function (other) {
-        return compare(this[InternalDataSym], other[InternalDataSym]) <= 0;
-    },
-    gt: function (other) {
-        return compare(this[InternalDataSym], other[InternalDataSym]) === 1;
-    },
-    gte: function (other) {
-        return compare(this[InternalDataSym], other[InternalDataSym]) >= 0;
-    },
-};
-NumericPrototype.toString = function () {
-    return stringify(this[InternalDataSym]);
-};
-
-defineKit({
-    literal: {
-        create(value) {
-            if (typeof value === "string") {
-                return this.literal.createString(value);
-            }
-            else if (typeof value === "number") {
-                return this.literal.createNumeric(value);
-            }
-            else {
-                return this.literal.createBoolean(value);
-            }
-        },
-        createString(value) {
-            return this.program.checker.createType({
-                kind: "String",
-                value,
-            });
-        },
-        createNumeric(value) {
-            const valueAsString = String(value);
-            return this.program.checker.createType({
-                kind: "Number",
-                value,
-                valueAsString,
-                numericValue: Numeric(valueAsString),
-            });
-        },
-        createBoolean(value) {
-            return this.program.checker.createType({
-                kind: "Boolean",
-                value,
-            });
-        },
-        isBoolean(type) {
-            return type.kind === "Boolean";
-        },
-        isString(type) {
-            return type.kind === "String";
-        },
-        isNumeric(type) {
-            return type.kind === "Number";
-        },
-        is(type) {
-            return (this.literal.isBoolean(type) || this.literal.isNumeric(type) || this.literal.isString(type));
-        },
-    },
-});
-
-/**
- * Filters the properties of a model by removing them from the model instance if
- * a given `filter` predicate is not satisfied.
- *
- * @param model - the model to filter properties on
- * @param filter - the predicate to filter properties with
- */
-/**
- * Creates a unique symbol for storing state on objects
- * @param name The name/description of the state
- */
-function createStateSymbol(name) {
-    return Symbol.for(`TypeSpec.${name}`);
-}
-
-/**
- * Helper class to track duplicate instance
- */
-class DuplicateTracker {
-    #entries = new Map();
-    /**
-     * Track usage of K.
-     * @param k key that is being checked for duplicate.
-     * @param v value that map to the key
-     */
-    track(k, v) {
-        const existing = this.#entries.get(k);
-        if (existing === undefined) {
-            this.#entries.set(k, [v]);
-        }
-        else {
-            existing.push(v);
-        }
-    }
-    /**
-     * Return iterator of all the duplicate entries.
-     */
-    *entries() {
-        for (const [k, v] of this.#entries.entries()) {
-            if (v.length > 1) {
-                yield [k, v];
-            }
-        }
-    }
-}
-
-function useStateMap(key) {
-    const getter = (program, target) => program.stateMap(key).get(target);
-    const setter = (program, target, value) => program.stateMap(key).set(target, value);
-    const mapGetter = (program) => program.stateMap(key);
-    return [getter, setter, mapGetter];
-}
-
-// Copyright (c) Microsoft Corporation
-// Licensed under the MIT license.
-// TypeSpec Visibility System
-// --------------------------
-// This module defines the core visibility system of the TypeSpec language. The
-// visibility system is used to decide when properties of a _conceptual resource_
-// are present. The system is based on the concept of _visibility classes_,
-// represented by TypeSpec enums. Each visibility class has a set of _visibility
-// modifiers_ that can be applied to a model property, each modifier represented
-// by a member of the visibility class enum.
-//
-// Each visibility class has a _default modifier set_ that is used when no
-// modifiers are specified for a property, and each property has an _active
-// modifier set_ that is used when analyzing the visibility of the property.
-//
-// Visibility can be _sealed_ for a program, property, or visibility class
-// within a property. Once visibility is sealed, it cannot be unsealed, and any
-// attempts to modify a sealed visibility will fail.
-/**
- * The global visibility store.
- *
- * This store is used to track the visibility modifiers
- */
-const [getVisibilityStore, setVisibilityStore] = useStateMap(createStateSymbol("visibilityStore"));
-/**
- * Stores the default modifier set for a given visibility class.
- */
-const [getDefaultModifiers, setDefaultModifiers] = useStateMap(createStateSymbol("defaultVisibilityModifiers"));
-/**
- * Gets the default modifier set for a visibility class. If no default modifier set has been set, this function will
- * initialize the default modifier set to ALL the visibility class's members.
- *
- * @param program - the program in which the visibility class occurs
- * @param visibilityClass - the visibility class to get the default modifier set for
- * @returns the default modifier set for the visibility class
- */
-function getDefaultModifierSetForClass(program, visibilityClass) {
-    const cached = getDefaultModifiers(program, visibilityClass);
-    if (cached)
-        return new Set(cached);
-    const defaultModifierSet = new Set(visibilityClass.members.values());
-    setDefaultModifiers(program, visibilityClass, defaultModifierSet);
-    // Explicitly clone the set again to prevent accidental modification of the default set.
-    return new Set(defaultModifierSet);
-}
-// #endregion
-// #region Visibility Analysis API
-/**
- * Returns the active visibility modifiers for a property in a given visibility class.
- *
- * This function is infallible. If the visibility modifiers for the given class have not been set explicitly, it will
- * return the default visibility modifiers for the class.
- *
- * @param program - the program in which the property occurs
- * @param property - the property to get visibility modifiers for
- * @param visibilityClass - the visibility class to get visibility modifiers for
- * @returns the set of active modifiers (enum members) for the property and visibility class
- */
-function getVisibilityForClass(program, property, visibilityClass) {
-    const store = getVisibilityStore(program, property);
-    return store?.get(visibilityClass) ?? getDefaultModifierSetForClass(program, visibilityClass);
-}
-// #endregion
-
-function isIntrinsicType(program, type, kind) {
-    return ignoreDiagnostics(program.checker.isTypeAssignableTo(type, program.checker.getStdType(kind), type));
-}
-
-const deprecatedKey = createStateSymbol("deprecated");
-/**
- * Returns complete deprecation details for the given type or node
- * @param program Program
- * @param typeOrNode A Type or Node to check for deprecation
- */
-function getDeprecationDetails(program, typeOrNode) {
-    function isType(maybeType) {
-        return typeof maybeType.kind === "string";
-    }
-    // If we're looking at a type, pull the deprecation details from the state map
-    if (isType(typeOrNode)) {
-        return program.stateMap(deprecatedKey).get(typeOrNode);
-    }
-    else {
-        // Look at the node for a deprecation directive
-        const deprecatedDirective = (typeOrNode.directives ?? []).find((directive) => directive.target.sv === "deprecated");
-        if (deprecatedDirective?.arguments[0].kind === SyntaxKind.StringLiteral) {
-            return {
-                message: deprecatedDirective.arguments[0].value,
-            };
-        }
-    }
-    return undefined;
+function useStateSet(key) {
+    const getter = (program, target) => program.stateSet(key).has(target);
+    const setter = (program, target) => program.stateSet(key).add(target);
+    return [getter, setter];
 }
 
 // Contains all intrinsic data setter or getter
@@ -29294,6 +29028,10 @@ function getMaxItemsAsNumeric(program, target) {
 function getMaxItems(program, target) {
     return getMaxItemsAsNumeric(program, target)?.asNumber() ?? undefined;
 }
+/** @internal */
+function setDocData(program, target, key, data) {
+    program.stateMap(getDocKey(key)).set(target, data);
+}
 function getDocKey(target) {
     switch (target) {
         case "self":
@@ -30901,7 +30639,7 @@ function getInterfaceName(iface, options) {
 }
 function getOperationName(op, options) {
     let opName = getIdentifierName(op.name, options);
-    if (op.node.templateParameters.length > 0) {
+    if (op.node && op.node.templateParameters.length > 0) {
         // template
         const params = op.node.templateParameters.map((t) => getIdentifierName(t.id.sv, options));
         opName += `<${params.join(", ")}>`;
@@ -30911,121 +30649,750 @@ function getOperationName(op, options) {
         : getNamespacePrefix(op.namespace, options);
     return `${prefix}${opName}`;
 }
-function getIdentifierName(name, options) {
-    return options?.printable ? printIdentifier(name) : name;
+function getIdentifierName(name, options) {
+    return options?.printable ? printIdentifier(name) : name;
+}
+function getStringTemplateName(type) {
+    if (type.stringValue) {
+        return `"${type.stringValue}"`;
+    }
+    return "string";
+}
+
+const regex = /^(application|audio|font|example|image|message|model|multipart|text|video|x-(?:[0-9A-Za-z!#$%&'*+.^_`|~-]+))\/([0-9A-Za-z!#$%&'*+.^_`|~-]+)$/;
+function parseMimeType(mimeType) {
+    const match = mimeType.match(regex);
+    if (match == null) {
+        return undefined;
+    }
+    const type = {
+        type: match[1],
+        ...parseSubType(match[2]),
+    };
+    return type;
+}
+function parseSubType(value) {
+    if (!value.includes("+"))
+        return { subtype: value };
+    const [subtype, suffix] = value.split("+", 2);
+    return { subtype, suffix };
+}
+
+const [getEncodedNamesMap, setEncodedNamesMap, getEncodedNamesStateMap] = useStateMap(createStateSymbol("encodedName"));
+function getEncodedName(program, target, mimeType) {
+    const mimeTypeObj = parseMimeType(mimeType);
+    if (mimeTypeObj === undefined) {
+        return undefined;
+    }
+    const resolvedMimeType = mimeTypeObj?.suffix
+        ? `${mimeTypeObj.type}/${mimeTypeObj.suffix}`
+        : mimeType;
+    return getEncodedNamesMap(program, target)?.get(resolvedMimeType);
+}
+/**
+ * Resolve the encoded name for the given type when serialized to the given mime type.
+ * If a specific value was provided by `@encodedName` decorator for that mime type it will return that otherwise it will return the name of the type.
+ *
+ * @example
+ *
+ * For the given
+ * ```tsp
+ * model Certificate {
+ *   @encodedName("application/json", "exp")
+ *   @encodedName("application/xml", "expiry")
+ *   expireAt: utcDateTime;
+ *
+ * }
+ * ```
+ *
+ * ```ts
+ * resolveEncodedName(program, type, "application/json") // exp
+ * resolveEncodedName(program, type, "application/merge-patch+json") // exp
+ * resolveEncodedName(program, type, "application/xml") // expireAt
+ * resolveEncodedName(program, type, "application/yaml") // expiry
+ * ```
+ */
+function resolveEncodedName(program, target, mimeType) {
+    return getEncodedName(program, target, mimeType) ?? target.name;
+}
+
+const [
+/**
+ * Check if the given property is the `@offset` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */
+isOffsetProperty, markOffset, 
+/** {@inheritdoc OffsetDecorator} */
+offsetDecorator,] = createMarkerDecorator("offset", createNumericValidation("offset"));
+const [
+/**
+ * Check if the given property is the `@pageIndex` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */
+isPageIndexProperty, markPageIndexProperty, 
+/** {@inheritdoc PageIndexDecorator} */
+pageIndexDecorator,] = createMarkerDecorator("pageIndex", createNumericValidation("pageIndex"));
+const [
+/**
+ * Check if the given property is the `@pageIndex` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */
+isPageSizeProperty, markPageSizeProperty, 
+/** {@inheritdoc PageSizeDecorator} */
+pageSizeDecorator,] = createMarkerDecorator("pageSize", createNumericValidation("pageSize"));
+const [
+/**
+ * Check if the given property is the `@pageIndex` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */
+isPageItemsProperty, markPageItemsProperty, 
+/** {@inheritdoc PageItemsDecorator} */
+pageItemsDecorator,] = createMarkerDecorator("pageItems", (context, target) => {
+    if (target.type.kind !== "Model" || !isArrayModelType(context.program, target.type)) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            messageId: "withExpected",
+            format: { decorator: "continuationToken", expected: "Array", to: getTypeName(target.type) },
+            target: context.decoratorTarget,
+        });
+        return false;
+    }
+    return true;
+});
+const [
+/**
+ * Check if the given property is the `@pageIndex` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */
+isContinuationTokenProperty, markContinuationTokenProperty, 
+/** {@inheritdoc ContinuationTokenDecorator} */
+continuationTokenDecorator,] = createMarkerDecorator("continuationToken", (context, target) => {
+    if (!isStringType(context.program, target.type)) {
+        reportDiagnostic(context.program, {
+            code: "decorator-wrong-target",
+            messageId: "withExpected",
+            format: { decorator: "continuationToken", expected: "string", to: getTypeName(target.type) },
+            target: context.decoratorTarget,
+        });
+        return false;
+    }
+    return true;
+});
+const [
+/**
+ * Check if the given property is the `@nextLink` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */
+isNextLink, markNextLink, 
+/** {@inheritdoc NextLinkDecorator} */
+nextLinkDecorator,] = createMarkerDecorator("nextLink");
+const [
+/**
+ * Check if the given property is the `@prevLink` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */ isPrevLink, markPrevLink, 
+/** {@inheritdoc PrevLinkDecorator} */
+prevLinkDecorator,] = createMarkerDecorator("prevLink");
+const [
+/**
+ * Check if the given property is the `@firstLink` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */ isFirstLink, markFirstLink, 
+/** {@inheritdoc FirstLinkDecorator} */
+firstLinkDecorator,] = createMarkerDecorator("firstLink");
+const [
+/**
+ * Check if the given property is the `@lastLink` property for a paging operation.
+ * @param program Program
+ * @param target Model Property
+ */ isLastLink, markLastLink, 
+/** {@inheritdoc LastLinkDecorator} */
+lastLinkDecorator,] = createMarkerDecorator("lastLink");
+const inputProps = new Set(["offset", "pageIndex", "pageSize", "continuationToken"]);
+const outputProps = new Set([
+    "pageItems",
+    "nextLink",
+    "prevLink",
+    "firstLink",
+    "lastLink",
+    "continuationToken",
+]);
+function findPagingProperties(program, op, base, source) {
+    const diags = createDiagnosticCollector();
+    const acceptableProps = source === "input" ? inputProps : outputProps;
+    const duplicateTracker = new DuplicateTracker();
+    const data = {};
+    navigateProperties(base, (property, path) => {
+        const kind = diags.pipe(getPagingProperty(program, property));
+        if (kind === undefined) {
+            return;
+        }
+        duplicateTracker.track(kind, property);
+        if (acceptableProps.has(kind)) {
+            data[kind] = { property, path };
+        }
+        else {
+            diags.add(createDiagnostic({
+                code: "invalid-paging-prop",
+                messageId: source === "input" ? "input" : "output",
+                format: { kind },
+                target: property,
+            }));
+        }
+    });
+    for (const [key, duplicates] of duplicateTracker.entries()) {
+        for (const prop of duplicates) {
+            diags.add(createDiagnostic({
+                code: "duplicate-paging-prop",
+                format: { kind: key, operationName: op.name },
+                target: prop,
+            }));
+        }
+    }
+    return diags.wrap(data);
+}
+function getPagingOperation(program, op) {
+    const diags = createDiagnosticCollector();
+    const result = {
+        input: diags.pipe(findPagingProperties(program, op, op.parameters, "input")),
+        output: diags.pipe(findPagingProperties(program, op, op.returnType, "output")),
+    };
+    if (result.output.pageItems === undefined) {
+        diags.add(createDiagnostic({
+            code: "missing-paging-items",
+            format: { operationName: op.name },
+            target: op,
+        }));
+        return diags.wrap(undefined);
+    }
+    return diags.wrap(result);
+}
+function navigateProperties(type, callback, path = []) {
+    switch (type.kind) {
+        case "Model":
+            for (const prop of type.properties.values()) {
+                callback(prop, [...path, prop]);
+                navigateProperties(prop.type, callback, [...path, prop]);
+            }
+            break;
+        case "Union":
+            for (const member of type.variants.values()) {
+                navigateProperties(member, callback, path);
+            }
+            break;
+        case "UnionVariant":
+            navigateProperties(type.type, callback, path);
+            break;
+    }
+}
+function getPagingProperty(program, prop) {
+    const diagnostics = [];
+    const props = {
+        offset: isOffsetProperty(program, prop),
+        pageIndex: isPageIndexProperty(program, prop),
+        pageItems: isPageItemsProperty(program, prop),
+        pageSize: isPageSizeProperty(program, prop),
+        continuationToken: isContinuationTokenProperty(program, prop),
+        nextLink: isNextLink(program, prop),
+        prevLink: isPrevLink(program, prop),
+        lastLink: isLastLink(program, prop),
+        firstLink: isFirstLink(program, prop),
+    };
+    const defined = Object.entries(props).filter((x) => !!x[1]);
+    if (defined.length > 1) {
+        diagnostics.push(createDiagnostic({
+            code: "incompatible-paging-props",
+            format: { kinds: defined.map((x) => x[0]).join(", ") },
+            target: prop,
+        }));
+    }
+    if (defined.length === 0) {
+        return [undefined, diagnostics];
+    }
+    return [defined[0][0], diagnostics];
+}
+function createMarkerDecorator(key, validate) {
+    const [isLink, markLink] = useStateSet(createStateSymbol(key));
+    const decorator = (...args) => {
+        if (validate && !validate(...args)) {
+            return;
+        }
+        const [context, target] = args;
+        markLink(context.program, target);
+    };
+    return [isLink, markLink, decorator];
+}
+function createNumericValidation(decoratorName) {
+    return (context, target) => {
+        if (!isNumericType(context.program, target.type)) {
+            reportDiagnostic(context.program, {
+                code: "decorator-wrong-target",
+                messageId: "withExpected",
+                format: {
+                    decorator: decoratorName,
+                    expected: "numeric",
+                    to: getTypeName(target.type),
+                },
+                target: context.decoratorTarget,
+            });
+            return false;
+        }
+        return true;
+    };
+}
+
+// Copyright (c) Microsoft Corporation
+// Licensed under the MIT license.
+// TypeSpec Visibility System
+// --------------------------
+// This module defines the core visibility system of the TypeSpec language. The
+// visibility system is used to decide when properties of a _conceptual resource_
+// are present. The system is based on the concept of _visibility classes_,
+// represented by TypeSpec enums. Each visibility class has a set of _visibility
+// modifiers_ that can be applied to a model property, each modifier represented
+// by a member of the visibility class enum.
+//
+// Each visibility class has a _default modifier set_ that is used when no
+// modifiers are specified for a property, and each property has an _active
+// modifier set_ that is used when analyzing the visibility of the property.
+//
+// Visibility can be _sealed_ for a program, property, or visibility class
+// within a property. Once visibility is sealed, it cannot be unsealed, and any
+// attempts to modify a sealed visibility will fail.
+/**
+ * The global visibility store.
+ *
+ * This store is used to track the visibility modifiers
+ */
+const [getVisibilityStore, setVisibilityStore] = useStateMap(createStateSymbol("visibilityStore"));
+/**
+ * Stores the default modifier set for a given visibility class.
+ */
+const [getDefaultModifiers, setDefaultModifiers] = useStateMap(createStateSymbol("defaultVisibilityModifiers"));
+/**
+ * Gets the default modifier set for a visibility class. If no default modifier set has been set, this function will
+ * initialize the default modifier set to ALL the visibility class's members.
+ *
+ * @param program - the program in which the visibility class occurs
+ * @param visibilityClass - the visibility class to get the default modifier set for
+ * @returns the default modifier set for the visibility class
+ */
+function getDefaultModifierSetForClass(program, visibilityClass) {
+    const cached = getDefaultModifiers(program, visibilityClass);
+    if (cached)
+        return new Set(cached);
+    const defaultModifierSet = new Set(visibilityClass.members.values());
+    setDefaultModifiers(program, visibilityClass, defaultModifierSet);
+    // Explicitly clone the set again to prevent accidental modification of the default set.
+    return new Set(defaultModifierSet);
+}
+// #endregion
+// #region Visibility Analysis API
+/**
+ * Returns the active visibility modifiers for a property in a given visibility class.
+ *
+ * This function is infallible. If the visibility modifiers for the given class have not been set explicitly, it will
+ * return the default visibility modifiers for the class.
+ *
+ * @param program - the program in which the property occurs
+ * @param property - the property to get visibility modifiers for
+ * @param visibilityClass - the visibility class to get visibility modifiers for
+ * @returns the set of active modifiers (enum members) for the property and visibility class
+ */
+function getVisibilityForClass(program, property, visibilityClass) {
+    const store = getVisibilityStore(program, property);
+    return store?.get(visibilityClass) ?? getDefaultModifierSetForClass(program, visibilityClass);
+}
+// #endregion
+
+function getLocationContext(program, type) {
+    const sourceLocation = getSourceLocation(type);
+    if (sourceLocation.isSynthetic) {
+        return { type: "synthetic" };
+    }
+    return program.getSourceFileLocationContext(sourceLocation.file);
+}
+
+/**
+ * Flow control for mutators.
+ *
+ * When filtering types in a mutator, the filter function may return MutatorFlow flags to control how mutation should
+ * proceed.
+ *
+ * @see {@link MutatorFilterFn}
+ *
+ * @experimental
+ */
+var MutatorFlow;
+(function (MutatorFlow) {
+    /**
+     * Mutate the type and recur, further mutating the type's children. This is the default behavior.
+     */
+    MutatorFlow[MutatorFlow["MutateAndRecur"] = 0] = "MutateAndRecur";
+    /**
+     * If this flag is set, the type will not be mutated.
+     */
+    MutatorFlow[MutatorFlow["DoNotMutate"] = 1] = "DoNotMutate";
+    /**
+     * If this flag is set, the mutator will not proceed recursively into the children of the type.
+     */
+    MutatorFlow[MutatorFlow["DoNotRecur"] = 2] = "DoNotRecur";
+})(MutatorFlow || (MutatorFlow = {}));
+// #endregion
+
+function replaceTemplatedStringFromProperties(formatString, sourceObject) {
+    // Template parameters are not valid source objects, just skip them
+    if (sourceObject.kind === "TemplateParameter") {
+        return formatString;
+    }
+    return formatString.replace(/{(\w+)}/g, (_, propName) => {
+        return sourceObject[propName];
+    });
+}
+const [getSummary, setSummary] = useStateMap(createStateSymbol("summary"));
+/**
+ * @doc attaches a documentation string. Works great with multi-line string literals.
+ *
+ * The first argument to @doc is a string, which may contain template parameters, enclosed in braces,
+ * which are replaced with an attribute for the type (commonly "name") passed as the second (optional) argument.
+ *
+ * @doc can be specified on any language element -- a model, an operation, a namespace, etc.
+ */
+const $doc = (context, target, text, sourceObject) => {
+    validateDecoratorUniqueOnNode(context, target, $doc);
+    if (sourceObject) {
+        text = replaceTemplatedStringFromProperties(text, sourceObject);
+    }
+    setDocData(context.program, target, "self", { value: text, source: "decorator" });
+};
+/**
+ * Get the documentation string for the given type.
+ * @param program Program
+ * @param target Type
+ * @returns Documentation value
+ */
+function getDoc(program, target) {
+    return getDocDataInternal(program, target, "self")?.value;
+}
+function isStringType(program, target) {
+    const stringType = program.checker.getStdType("string");
+    return (target.kind === "Scalar" && program.checker.isTypeAssignableTo(target, stringType, target)[0]);
+}
+function isNumericType(program, target) {
+    const numericType = program.checker.getStdType("numeric");
+    return (target.kind === "Scalar" && program.checker.isTypeAssignableTo(target, numericType, target)[0]);
+}
+// -- @error decorator ----------------------
+const [getErrorState, setErrorState] = useStateSet(createStateSymbol("error"));
+/**
+ * Check if the type is an error model or a descendant of an error model.
+ */
+function isErrorModel(program, target) {
+    if (target.kind !== "Model") {
+        return false;
+    }
+    let current = target;
+    while (current) {
+        if (getErrorState(program, current)) {
+            return true;
+        }
+        current = current.baseModel;
+    }
+    return false;
+}
+// -- @format decorator ---------------------
+const [getFormat, setFormat] = useStateMap(createStateSymbol("format"));
+const [getEncode, setEncodeData] = useStateMap(createStateSymbol("encode"));
+
+defineKit({
+    enum: {
+        create(desc) {
+            const en = this.program.checker.createType({
+                kind: "Enum",
+                name: desc.name,
+                decorators: decoratorApplication(this, desc.decorators),
+                members: createRekeyableMap(),
+            });
+            if (Array.isArray(desc.members)) {
+                for (const member of desc.members) {
+                    member.enum = en;
+                    en.members.set(member.name, member);
+                }
+            }
+            else {
+                for (const [name, member] of Object.entries(desc.members ?? {})) {
+                    en.members.set(name, this.enumMember.create({ name, value: member, enum: en }));
+                }
+            }
+            this.program.checker.finishType(en);
+            return en;
+        },
+        is(type) {
+            return type.kind === "Enum";
+        },
+        createFromUnion(type) {
+            if (!type.name) {
+                throw new Error("Cannot create an enum from an anonymous union.");
+            }
+            const enumMembers = [];
+            for (const variant of type.variants.values()) {
+                if ((variant.name && typeof variant.name === "symbol") ||
+                    (!this.literal.isString(variant.type) && !this.literal.isNumeric(variant.type))) {
+                    continue;
+                }
+                const variantDoc = getDoc(this.program, variant);
+                enumMembers.push(this.enumMember.create({
+                    name: variant.name,
+                    value: variant.type.value,
+                    decorators: variantDoc ? [[$doc, variantDoc]] : undefined,
+                }));
+            }
+            const unionDoc = getDoc(this.program, type);
+            return this.enum.create({
+                name: type.name,
+                members: enumMembers,
+                decorators: unionDoc ? [[$doc, unionDoc]] : undefined,
+            });
+        },
+    },
+});
+
+class InvalidNumericError extends Error {
+    code = "InvalidNumeric";
+}
+/** @internal */
+const InternalDataSym = Symbol.for("NumericInternalData");
+/**
+ * Represent any possible numeric value
+ */
+function Numeric(stringValue) {
+    if (new.target) {
+        throw new Error("Numeric is not a constructor");
+    }
+    const data = parse(stringValue);
+    const isInteger = data.d === 0;
+    const obj = {
+        [InternalDataSym]: data,
+        isInteger,
+    };
+    // We are explicitly not using a class here due to version mismatch between the compiler and the runtime that could happen and break instanceof checks.
+    const numeric = setTypedProptotype(obj, NumericPrototype);
+    return Object.freeze(numeric);
+}
+function setTypedProptotype(obj, prototype) {
+    Object.setPrototypeOf(obj, prototype);
+    return obj;
+}
+function parse(original) {
+    let stringValue = original;
+    let start = 0;
+    let sign = 1;
+    let n;
+    let exp;
+    let decimal = undefined;
+    if (stringValue[0] === "-") {
+        start = 1;
+        sign = -1;
+    }
+    const second = stringValue[start + 1]?.toLowerCase();
+    if (stringValue[start] === "0" && (second === "b" || second === "x" || second === "o")) {
+        try {
+            n = BigInt(stringValue.slice(start));
+            exp = n.toString().length;
+            decimal = 0;
+        }
+        catch {
+            throw new InvalidNumericError(`Invalid numeric value: ${original}`);
+        }
+    }
+    else {
+        // Skip leading 0.
+        while (stringValue[start] === "0") {
+            start++;
+        }
+        const decimalPointIndex = stringValue.indexOf(".");
+        const adjustedPointIndex = decimalPointIndex - start;
+        // Decimal point?
+        if (decimalPointIndex !== -1) {
+            exp = adjustedPointIndex;
+            stringValue = stringValue.replace(".", "");
+        }
+        let i;
+        if ((i = stringValue.search(/e/i)) > 0) {
+            // Determine exponent.
+            if (exp === undefined) {
+                exp = i - start;
+            }
+            exp += Number(stringValue.slice(i + 1));
+            stringValue = stringValue.slice(start, i);
+            decimal = Math.max(stringValue.length - exp, 0);
+        }
+        else if (exp === undefined) {
+            // Integer.
+            exp = stringValue.length - start;
+            stringValue = stringValue.slice(start);
+        }
+        else {
+            stringValue = stringValue.slice(start);
+        }
+        let end = stringValue.length;
+        while (stringValue[end - 1] === "0" && end > adjustedPointIndex) {
+            end--;
+        }
+        // Only if there is 0 before the decimal point, keeps checking how many 0 there is after it and update the exponent accordingly.
+        if (start === adjustedPointIndex + 1) {
+            let cur = adjustedPointIndex;
+            while (stringValue[cur] === "0" && cur < end) {
+                cur++;
+                exp--;
+            }
+        }
+        try {
+            stringValue = stringValue.slice(0, end);
+            stringValue = stringValue + "0".repeat(Math.max(exp - stringValue.length, 0)); // add remaining zeros for cases like 3e30
+            n = BigInt(stringValue);
+            if (n === 0n) {
+                decimal = 0;
+            }
+            else if (decimal === undefined) {
+                decimal = Math.max(stringValue.length - Math.max(exp, 0), 0);
+            }
+        }
+        catch {
+            throw new InvalidNumericError(`Invalid numeric value: ${original}`);
+        }
+    }
+    return { n, e: exp, s: sign, d: decimal };
+}
+function stringify(value) {
+    if (value.n === 0n)
+        return "0";
+    const n = value.n.toString();
+    const sign = value.s === -1 ? "-" : "";
+    const int = value.e <= 0 ? "0" : n.slice(0, value.e);
+    const decimal = value.e < n.length ? "." + n.slice(-value.d).padStart(value.d, "0") : "";
+    return sign + int + decimal;
 }
-function getStringTemplateName(type) {
-    if (type.stringValue) {
-        return `"${type.stringValue}"`;
+const equals = (a, b) => a.n === b.n && a.e === b.e;
+const compare = (a, b) => {
+    if (a.s < b.s) {
+        return -1;
     }
-    return "string";
-}
-
-const regex = /^(application|audio|font|example|image|message|model|multipart|text|video|x-(?:[0-9A-Za-z!#$%&'*+.^_`|~-]+))\/([0-9A-Za-z!#$%&'*+.^_`|~-]+)$/;
-function parseMimeType(mimeType) {
-    const match = mimeType.match(regex);
-    if (match == null) {
-        return undefined;
+    else if (a.s > b.s) {
+        return 1;
     }
-    const type = {
-        type: match[1],
-        ...parseSubType(match[2]),
-    };
-    return type;
-}
-function parseSubType(value) {
-    if (!value.includes("+"))
-        return { subtype: value };
-    const [subtype, suffix] = value.split("+", 2);
-    return { subtype, suffix };
-}
-
-const [getEncodedNamesMap, setEncodedNamesMap, getEncodedNamesStateMap] = useStateMap(createStateSymbol("encodedName"));
-function getEncodedName(program, target, mimeType) {
-    const mimeTypeObj = parseMimeType(mimeType);
-    if (mimeTypeObj === undefined) {
-        return undefined;
+    const neg = a.s;
+    if (a.e < b.e) {
+        return (-1 * neg);
     }
-    const resolvedMimeType = mimeTypeObj?.suffix
-        ? `${mimeTypeObj.type}/${mimeTypeObj.suffix}`
-        : mimeType;
-    return getEncodedNamesMap(program, target)?.get(resolvedMimeType);
-}
-/**
- * Resolve the encoded name for the given type when serialized to the given mime type.
- * If a specific value was provided by `@encodedName` decorator for that mime type it will return that otherwise it will return the name of the type.
- *
- * @example
- *
- * For the given
- * ```tsp
- * model Certificate {
- *   @encodedName("application/json", "exp")
- *   @encodedName("application/xml", "expiry")
- *   expireAt: utcDateTime;
- *
- * }
- * ```
- *
- * ```ts
- * resolveEncodedName(program, type, "application/json") // exp
- * resolveEncodedName(program, type, "application/merge-patch+json") // exp
- * resolveEncodedName(program, type, "application/xml") // expireAt
- * resolveEncodedName(program, type, "application/yaml") // expiry
- * ```
- */
-function resolveEncodedName(program, target, mimeType) {
-    return getEncodedName(program, target, mimeType) ?? target.name;
-}
-
-function getLocationContext(program, type) {
-    const sourceLocation = getSourceLocation(type);
-    if (sourceLocation.isSynthetic) {
-        return { type: "synthetic" };
+    else if (a.e > b.e) {
+        return (1 * neg);
     }
-    return program.getSourceFileLocationContext(sourceLocation.file);
-}
-
-/**
- * Flow control for mutators.
- *
- * When filtering types in a mutator, the filter function may return MutatorFlow flags to control how mutation should
- * proceed.
- *
- * @see {@link MutatorFilterFn}
- *
- * @experimental
- */
-var MutatorFlow;
-(function (MutatorFlow) {
-    /**
-     * Mutate the type and recur, further mutating the type's children. This is the default behavior.
-     */
-    MutatorFlow[MutatorFlow["MutateAndRecur"] = 0] = "MutateAndRecur";
-    /**
-     * If this flag is set, the type will not be mutated.
-     */
-    MutatorFlow[MutatorFlow["DoNotMutate"] = 1] = "DoNotMutate";
-    /**
-     * If this flag is set, the mutator will not proceed recursively into the children of the type.
-     */
-    MutatorFlow[MutatorFlow["DoNotRecur"] = 2] = "DoNotRecur";
-})(MutatorFlow || (MutatorFlow = {}));
-// #endregion
+    let aN = a.n;
+    let bN = b.n;
+    if (a.d < b.d) {
+        aN *= 10n ** BigInt(b.d - a.d);
+    }
+    else {
+        bN *= 10n ** BigInt(a.d - b.d);
+    }
+    if (aN < bN)
+        return (-1 * neg);
+    if (aN > bN)
+        return (1 * neg);
+    return 0;
+};
+const NumericPrototype = {
+    toString: function () {
+        return stringify(this[InternalDataSym]);
+    },
+    asNumber: function () {
+        const num = Number(stringify(this[InternalDataSym]));
+        return equals(this[InternalDataSym], Numeric(num.toString())[InternalDataSym]) ? num : null;
+    },
+    asBigInt: function () {
+        if (!this.isInteger) {
+            return null;
+        }
+        const { s, n } = this[InternalDataSym];
+        return BigInt(s) * n;
+    },
+    equals: function (other) {
+        return equals(this[InternalDataSym], other[InternalDataSym]);
+    },
+    lt: function (other) {
+        return compare(this[InternalDataSym], other[InternalDataSym]) === -1;
+    },
+    lte: function (other) {
+        return compare(this[InternalDataSym], other[InternalDataSym]) <= 0;
+    },
+    gt: function (other) {
+        return compare(this[InternalDataSym], other[InternalDataSym]) === 1;
+    },
+    gte: function (other) {
+        return compare(this[InternalDataSym], other[InternalDataSym]) >= 0;
+    },
+};
+NumericPrototype.toString = function () {
+    return stringify(this[InternalDataSym]);
+};
 
-const [getSummary, setSummary] = useStateMap(createStateSymbol("summary"));
-/**
- * Get the documentation string for the given type.
- * @param program Program
- * @param target Type
- * @returns Documentation value
- */
-function getDoc(program, target) {
-    return getDocDataInternal(program, target, "self")?.value;
-}
-// -- @format decorator ---------------------
-const [getFormat, setFormat] = useStateMap(createStateSymbol("format"));
-const [getEncode, setEncodeData] = useStateMap(createStateSymbol("encode"));
+defineKit({
+    literal: {
+        create(value) {
+            if (typeof value === "string") {
+                return this.literal.createString(value);
+            }
+            else if (typeof value === "number") {
+                return this.literal.createNumeric(value);
+            }
+            else {
+                return this.literal.createBoolean(value);
+            }
+        },
+        createString(value) {
+            return this.program.checker.createType({
+                kind: "String",
+                value,
+            });
+        },
+        createNumeric(value) {
+            const valueAsString = String(value);
+            return this.program.checker.createType({
+                kind: "Number",
+                value,
+                valueAsString,
+                numericValue: Numeric(valueAsString),
+            });
+        },
+        createBoolean(value) {
+            return this.program.checker.createType({
+                kind: "Boolean",
+                value,
+            });
+        },
+        isBoolean(type) {
+            return type.kind === "Boolean";
+        },
+        isString(type) {
+            return type.kind === "String";
+        },
+        isNumeric(type) {
+            return type.kind === "Number";
+        },
+        is(type) {
+            return (this.literal.isBoolean(type) || this.literal.isNumeric(type) || this.literal.isString(type));
+        },
+    },
+});
 
 defineKit({
     modelProperty: {
@@ -31045,7 +31412,6 @@ defineKit({
             return this.program.checker.createType({
                 kind: "ModelProperty",
                 name: desc.name,
-                node: undefined,
                 type: desc.type,
                 optional: desc.optional ?? false,
                 decorators: [],
@@ -31065,7 +31431,6 @@ defineKit({
                 name: desc.name ?? "",
                 decorators: decoratorApplication(this, desc.decorators),
                 properties: properties,
-                node: undefined,
                 derivedModels: desc.derivedModels ?? [],
                 sourceModels: desc.sourceModels ?? [],
                 indexer: desc.indexer,
@@ -31143,13 +31508,13 @@ defineKit({
             }
             return undefined;
         },
-        getDiscriminatedUnion(model) {
+        getDiscriminatedUnion: createDiagnosable(function (model) {
             const discriminator = getDiscriminator(this.program, model);
             if (!discriminator) {
-                return undefined;
+                return [undefined, []];
             }
-            return ignoreDiagnostics(getDiscriminatedUnionFromInheritance(model, discriminator));
-        },
+            return getDiscriminatedUnionFromInheritance(model, discriminator);
+        }),
     },
 });
 
@@ -31158,6 +31523,9 @@ defineKit({
         is(type) {
             return type.kind === "Operation";
         },
+        getPagingMetadata: createDiagnosable(function (operation) {
+            return getPagingOperation(this.program, operation);
+        }),
         create(desc) {
             const parametersModel = this.model.create({
                 name: `${desc.name}Parameters`,
@@ -31172,7 +31540,6 @@ defineKit({
                 decorators: [],
                 parameters: parametersModel,
                 returnType: desc.returnType,
-                node: undefined,
             });
             this.program.checker.finishType(operation);
             return operation;
@@ -31292,6 +31659,23 @@ function extendsStdType(typeName) {
     };
 }
 
+defineKit({
+    tuple: {
+        is(type) {
+            return type.kind === "Tuple";
+        },
+        create(values = []) {
+            const tuple = this.program.checker.createType({
+                kind: "Tuple",
+                name: "Tuple",
+                values,
+            });
+            this.program.checker.finishType(tuple);
+            return tuple;
+        },
+    },
+});
+
 /**
  * Get a plausible name for the given type.
  * @experimental
@@ -31386,7 +31770,7 @@ defineKit({
             return clone;
         },
         isError(type) {
-            return isErrorType(type);
+            return isErrorModel(this.program, type);
         },
         getEncodedName(type, encoding) {
             return resolveEncodedName(this.program, type, encoding);
@@ -31402,7 +31786,7 @@ defineKit({
         },
         getDiscriminator(type) {
             let discriminator;
-            if ($$1.model.is(type)) {
+            if (this.model.is(type)) {
                 discriminator = getDiscriminator(this.program, type);
             }
             else {
@@ -31455,7 +31839,6 @@ defineKit({
                 name: desc.name ?? Symbol("name"),
                 decorators: decoratorApplication(this, desc.decorators),
                 type: desc.type,
-                node: undefined,
                 union: desc.union,
             });
             this.program.checker.finishType(variant);
@@ -31483,7 +31866,6 @@ defineKit({
                     return Array.from(this.variants.values()).map((v) => v.type);
                 },
                 expression: desc.name === undefined,
-                node: undefined,
             });
             if (Array.isArray(desc.variants)) {
                 for (const variant of desc.variants) {
@@ -31499,6 +31881,22 @@ defineKit({
             this.program.checker.finishType(union);
             return union;
         },
+        createFromEnum(type) {
+            const enumDoc = getDoc(this.program, type);
+            return this.union.create({
+                name: type.name,
+                decorators: enumDoc ? [[$doc, enumDoc]] : undefined,
+                variants: Array.from(type.members.values()).map((member) => {
+                    const memberDoc = getDoc(this.program, member);
+                    const value = member.value ?? member.name;
+                    return this.unionVariant.create({
+                        name: member.name,
+                        type: this.literal.create(value),
+                        decorators: memberDoc ? [[$doc, memberDoc]] : undefined,
+                    });
+                }),
+            });
+        },
         is(type) {
             return type.kind === "Union";
         },
@@ -31536,9 +31934,9 @@ defineKit({
         isExpression(type) {
             return type.name === undefined || type.name === "";
         },
-        getDiscriminatedUnion(type) {
-            return ignoreDiagnostics(getDiscriminatedUnion(this.program, type));
-        },
+        getDiscriminatedUnion: createDiagnosable(function (type) {
+            return getDiscriminatedUnion(this.program, type);
+        }),
     },
 });
 
@@ -31646,9 +32044,28 @@ function createTypekit(realm) {
             const value = Reflect.get(target, prop, receiver);
             // Wrap functions to set `this` correctly
             if (typeof value === "function") {
-                return function (...args) {
+                const proxyWrapper = function (...args) {
+                    // Call the original function (`value`) with the correct `this` (the proxy)
                     return value.apply(proxy, args);
                 };
+                // functions may also have properties added to them, like in the case of `withDiagnostics`.
+                // Copy enumerable properties from the original function (`value`) to the wrapper
+                for (const propName of Object.keys(value)) {
+                    const originalPropValue = value[propName];
+                    if (typeof originalPropValue === "function") {
+                        // If the property is a function, wrap it to ensure `this` is bound correctly
+                        proxyWrapper[propName] = function (...args) {
+                            // Call the original property function with `this` bound to the proxy
+                            return originalPropValue.apply(proxy, args);
+                        };
+                    }
+                    else {
+                        // If the property is not a function, copy it directly
+                        // Use Reflect.defineProperty to handle potential getters/setters correctly, though Object.keys usually only returns data properties.
+                        Reflect.defineProperty(proxyWrapper, propName, Reflect.getOwnPropertyDescriptor(value, propName));
+                    }
+                }
+                return proxyWrapper;
             }
             // Only wrap objects marked as Typekit namespaces
             if (typeof value === "object" && value !== null && isTypekitNamespace(value)) {
@@ -31665,11 +32082,7 @@ function isTypekitNamespace(obj) {
     return obj && !!obj[TypekitNamespaceSymbol];
 }
 // #region Default Typekit
-const CURRENT_PROGRAM = Symbol.for("TypeSpec.Typekit.CURRENT_PROGRAM");
 const DEFAULT_REALM = Symbol.for("TypeSpec.Typekit.DEFAULT_TYPEKIT_REALM");
-function getCurrentProgram() {
-    return globalThis[CURRENT_PROGRAM];
-}
 function _$(arg) {
     let realm;
     if (Object.hasOwn(arg, "projectRoot")) {
@@ -31685,26 +32098,16 @@ function _$(arg) {
 /**
  * Typekit - Utilities for working with TypeSpec types.
  *
- * The default typekit `$` can be used to manipulate types in the current program.
- *
- * Each typekit is associated with a Realm in which it operates. The default typekit
- * will use the default typekit realm for the current program.
+ * Each typekit is associated with a Realm in which it operates.
  *
- * Alternatively, to work in a specific realm, you can get the typekit associated
- * with that realm by calling `$` with the realm as an argument, or by calling
- * `$` with a program as an argument (in this case, it will use that program's
- * default typekit realm or create one if it does not already exist).
+ * You can get the typekit associated with that realm by calling
+ * `$` with the realm as an argument, or by calling `$` with a program
+ * as an argument (in this case, it will use that program's default
+ * typekit realm or create one if it does not already exist).
  *
  * @example
  * ```ts
- * import { $ } from "@typespec/compiler/experimental";
- *
- * const clone = $.type.clone(inputType);
- * ```
- *
- * @example
- * ```ts
- * import { $, Realm } from "@typespec/compiler/experimental";
+ * import { unsafe_$ as $, Realm } from "@typespec/compiler/experimental";
  *
  * const realm = new Realm(program, "my custom realm");
  *
@@ -31713,30 +32116,16 @@ function _$(arg) {
  *
  * @example
  * ```ts
- * import { $ } from "@typespec/compiler/experimental";
- *
- * const projectedProgram = projectProgram(program, ...);
+ * import { unsafe_$ as $ } from "@typespec/compiler/experimental";
  *
- * const clone = $(projectedProgram).type.clone(inputType);
+ * const clone = $(program).type.clone(inputType);
  * ```
  *
  * @see {@link Realm}
  *
  * @experimental
  */
-const $$1 = new Proxy(_$, {
-    get(_target, prop, _receiver) {
-        const currentProgram = getCurrentProgram();
-        compilerAssert(currentProgram !== undefined, "Default typekits may not be used until a program is set in the compiler.");
-        if (prop === "program")
-            return currentProgram;
-        const realm = (currentProgram[DEFAULT_REALM] ??= new Realm(currentProgram, "default typekit realm"));
-        if (prop === "realm")
-            return realm;
-        const tk = _$(realm);
-        return Reflect.get(tk, prop, tk);
-    },
-});
+const $$1 = _$;
 // #endregion
 
 var _a;
@@ -32226,7 +32615,7 @@ function filterModelProperties(program, model, filter) {
         return model;
     }
     const realm = Realm.realmForType.get(model);
-    const typekit = realm ? $$1(realm) : $$1;
+    const typekit = realm ? $$1(realm) : $$1(program);
     const newModel = typekit.model.create({
         name: "",
         indexer: undefined,
@@ -33611,7 +34000,7 @@ let manifest;
 try {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    manifest = (await import('../manifest-Cmvvh_kl.js')).default;
+    manifest = (await import('../manifest-DR_CKuUi.js')).default;
 }
 catch {
     const name = "../dist/manifest.js";