@typespec/html-program-viewer 0.65.0 → 0.66.0-dev.1

package/dist/manifest-oMDJJFgr.js

@@ -0,0 +1,6 @@
+const manifest = {
+  "version": "0.65.1",
+  "commit": "ba241e8e5561e3b99d4a7b6195aa193c35cbae63"
+};
+
+export { manifest as default };

package/dist/react/index.js

@@ -18110,7 +18110,7 @@ let manifest;
 try {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    manifest = (await import('../manifest-BNuBm9Cd.js')).default;
+    manifest = (await import('../manifest-oMDJJFgr.js')).default;
 }
 catch {
     const name = "../dist/manifest.js";
@@ -28630,6 +28630,64 @@ const stateKeys = {
     errorsDocs: createStateSymbol("errorDocs"),
     discriminator: createStateSymbol("discriminator"),
 };
+function getMinValueAsNumeric(program, target) {
+    return program.stateMap(stateKeys.minValues).get(target);
+}
+function getMinValue(program, target) {
+    return getMinValueAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+function getMaxValueAsNumeric(program, target) {
+    return program.stateMap(stateKeys.maxValues).get(target);
+}
+function getMaxValue(program, target) {
+    return getMaxValueAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+function getMinValueExclusiveAsNumeric(program, target) {
+    return program.stateMap(stateKeys.minValueExclusive).get(target);
+}
+function getMinValueExclusive(program, target) {
+    return getMinValueExclusiveAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+function getMaxValueExclusiveAsNumeric(program, target) {
+    return program.stateMap(stateKeys.maxValueExclusive).get(target);
+}
+function getMaxValueExclusive(program, target) {
+    return getMaxValueExclusiveAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+/**
+ * Get the minimum length of a string type as a {@link Numeric} value.
+ * @param program Current program
+ * @param target Type with the `@minLength` decorator
+ */
+function getMinLengthAsNumeric(program, target) {
+    return program.stateMap(stateKeys.minLength).get(target);
+}
+function getMinLength(program, target) {
+    return getMinLengthAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+/**
+ * Get the minimum length of a string type as a {@link Numeric} value.
+ * @param program Current program
+ * @param target Type with the `@maxLength` decorator
+ */
+function getMaxLengthAsNumeric(program, target) {
+    return program.stateMap(stateKeys.maxLength).get(target);
+}
+function getMaxLength(program, target) {
+    return getMaxLengthAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+function getMinItemsAsNumeric(program, target) {
+    return program.stateMap(stateKeys.minItems).get(target);
+}
+function getMinItems(program, target) {
+    return getMinItemsAsNumeric(program, target)?.asNumber() ?? undefined;
+}
+function getMaxItemsAsNumeric(program, target) {
+    return program.stateMap(stateKeys.maxItems).get(target);
+}
+function getMaxItems(program, target) {
+    return getMaxItemsAsNumeric(program, target)?.asNumber() ?? undefined;
+}
 function getDocKey(target) {
     switch (target) {
         case "self":
@@ -28650,8 +28708,50 @@ function getDocKey(target) {
 function getDocDataInternal(program, target, key) {
     return program.stateMap(getDocKey(key)).get(target);
 }
+function getDiscriminator(program, entity) {
+    return program.stateMap(stateKeys.discriminator).get(entity);
+}
 // #endregion
 
+/**
+ * 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 getLocationContext(program, type) {
+    const sourceLocation = getSourceLocation(type);
+    if (sourceLocation.isSynthetic) {
+        return { type: "synthetic" };
+    }
+    return program.getSourceFileLocationContext(sourceLocation.file);
+}
+
 //
 // Generated by scripts/regen-nonascii-map.js
 // on node v18.16.0 with unicode 15.0.
@@ -29422,6 +29522,49 @@ function lookupInNonAsciiMap(codePoint, map) {
     return false;
 }
 
+/**
+ * Print a string as a TypeSpec identifier. If the string is a valid identifier, return it as is otherwise wrap it into backticks.
+ * @param sv Identifier string value.
+ * @returns Identifier string as it would be represented in a TypeSpec file.
+ *
+ * @example
+ * ```ts
+ * printIdentifier("foo") // foo
+ * printIdentifier("foo bar") // `foo bar`
+ * ```
+ */
+function printIdentifier(sv) {
+    if (needBacktick(sv)) {
+        const escapedString = sv
+            .replace(/\\/g, "\\\\")
+            .replace(/\n/g, "\\n")
+            .replace(/\r/g, "\\r")
+            .replace(/\t/g, "\\t")
+            .replace(/`/g, "\\`");
+        return `\`${escapedString}\``;
+    }
+    else {
+        return sv;
+    }
+}
+function needBacktick(sv) {
+    if (sv.length === 0) {
+        return false;
+    }
+    if (Keywords.has(sv)) {
+        return true;
+    }
+    let cp = sv.codePointAt(0);
+    if (!isIdentifierStart(cp)) {
+        return true;
+    }
+    let pos = 0;
+    do {
+        pos += utf16CodeUnits(cp);
+    } while (pos < sv.length && isIdentifierContinue((cp = sv.codePointAt(pos))));
+    return pos < sv.length;
+}
+
 var Token;
 (function (Token) {
     Token[Token["None"] = 0] = "None";
@@ -29838,12 +29981,28 @@ function getDeprecationDetails(program, typeOrNode) {
 function isErrorType(type) {
     return "kind" in type && type.kind === "Intrinsic" && type.name === "ErrorType";
 }
+function isNeverType(type) {
+    return "kind" in type && type.kind === "Intrinsic" && type.name === "never";
+}
 function isType(entity) {
     return entity.entityKind === "Type";
 }
 function isValue(entity) {
     return entity.entityKind === "Value";
 }
+/**
+ * @param type Model type
+ */
+function isArrayModelType(program, type) {
+    return Boolean(type.indexer && type.indexer.key.name === "integer");
+}
+/**
+ * Check if a model is an array type.
+ * @param type Model type
+ */
+function isRecordModelType(program, type) {
+    return Boolean(type.indexer && type.indexer.key.name === "string");
+}
 /**
  * Check the given type is a finished template instance.
  */
@@ -29853,48 +30012,167 @@ function isTemplateInstance(type) {
         !maybeTemplateType.templateMapper.partial &&
         maybeTemplateType.isFinished);
 }
-
 /**
- * Print a string as a TypeSpec identifier. If the string is a valid identifier, return it as is otherwise wrap it into backticks.
- * @param sv Identifier string value.
- * @returns Identifier string as it would be represented in a TypeSpec file.
- *
- * @example
- * ```ts
- * printIdentifier("foo") // foo
- * printIdentifier("foo bar") // `foo bar`
- * ```
+ * Resolve if the type was created from a template type or is a template type declaration.
  */
-function printIdentifier(sv) {
-    if (needBacktick(sv)) {
-        const escapedString = sv
-            .replace(/\\/g, "\\\\")
-            .replace(/\n/g, "\\n")
-            .replace(/\r/g, "\\r")
-            .replace(/\t/g, "\\t")
-            .replace(/`/g, "\\`");
-        return `\`${escapedString}\``;
+function isTemplateDeclarationOrInstance(type) {
+    if (type.node === undefined) {
+        return false;
     }
-    else {
-        return sv;
+    const node = type.node;
+    return node.templateParameters && node.templateParameters.length > 0;
+}
+
+function getDiscriminatedUnion(type, discriminator) {
+    switch (type.kind) {
+        case "Model":
+            return getDiscriminatedUnionForModel(type, discriminator);
+        case "Union":
+            return getDiscriminatedUnionForUnion(type, discriminator);
+    }
+}
+function getDiscriminatedUnionForUnion(type, discriminator) {
+    const variants = new Map();
+    const diagnostics = [];
+    const duplicates = new DuplicateTracker();
+    for (const variant of type.variants.values()) {
+        if (variant.type.kind !== "Model") {
+            diagnostics.push(createDiagnostic({
+                code: "invalid-discriminated-union-variant",
+                format: { name: variant.name.toString() },
+                target: variant,
+            }));
+            continue;
+        }
+        const prop = getDiscriminatorProperty(variant.type, discriminator, diagnostics);
+        if (prop === undefined) {
+            diagnostics.push(createDiagnostic({
+                code: "invalid-discriminated-union-variant",
+                messageId: "noDiscriminant",
+                format: { name: variant.name.toString(), discriminant: discriminator.propertyName },
+                target: variant,
+            }));
+            continue;
+        }
+        const key = getStringValue(prop.type);
+        if (key) {
+            duplicates.track(key, variant.type);
+            variants.set(key, variant.type);
+        }
+        else {
+            diagnostics.push(createDiagnostic({
+                code: "invalid-discriminated-union-variant",
+                messageId: "wrongDiscriminantType",
+                format: { name: variant.name.toString(), discriminant: discriminator.propertyName },
+                target: variant.type,
+            }));
+        }
+    }
+    reportDuplicateDiscriminatorValues(duplicates, diagnostics);
+    const discriminatedUnion = {
+        propertyName: discriminator.propertyName,
+        variants,
+    };
+    return [discriminatedUnion, diagnostics];
+}
+function getDiscriminatedUnionForModel(type, discriminator) {
+    const variants = new Map();
+    const diagnostics = [];
+    const duplicates = new DuplicateTracker();
+    function checkForVariantsIn(current) {
+        for (const derivedModel of current.derivedModels) {
+            if (isTemplateDeclarationOrInstance(derivedModel)) {
+                continue; // Skip template instances as they should be used with `model is`
+            }
+            const keys = getDiscriminatorValues(derivedModel, discriminator, diagnostics);
+            if (keys === undefined) {
+                if (derivedModel.derivedModels.length === 0) {
+                    diagnostics.push(createDiagnostic({
+                        code: "missing-discriminator-property",
+                        format: { discriminator: discriminator.propertyName },
+                        target: derivedModel,
+                    }));
+                }
+                else {
+                    checkForVariantsIn(derivedModel);
+                }
+            }
+            else {
+                for (const key of keys) {
+                    duplicates.track(key, derivedModel);
+                    variants.set(key, derivedModel);
+                }
+            }
+        }
+    }
+    checkForVariantsIn(type);
+    reportDuplicateDiscriminatorValues(duplicates, diagnostics);
+    const discriminatedUnion = {
+        propertyName: discriminator.propertyName,
+        variants,
+    };
+    return [discriminatedUnion, diagnostics];
+}
+function reportDuplicateDiscriminatorValues(duplicates, diagnostics) {
+    for (const [duplicateKey, models] of duplicates.entries()) {
+        for (const model of models) {
+            diagnostics.push(createDiagnostic({
+                code: "invalid-discriminator-value",
+                messageId: "duplicate",
+                format: { discriminator: duplicateKey },
+                target: model,
+            }));
+        }
     }
 }
-function needBacktick(sv) {
-    if (sv.length === 0) {
-        return false;
+function getDiscriminatorProperty(model, discriminator, diagnostics) {
+    const prop = model.properties.get(discriminator.propertyName);
+    if (prop && prop.optional) {
+        diagnostics.push(createDiagnostic({
+            code: "invalid-discriminator-value",
+            messageId: "required",
+            target: prop,
+        }));
     }
-    if (Keywords.has(sv)) {
-        return true;
+    return prop;
+}
+function getDiscriminatorValues(model, discriminator, diagnostics) {
+    const prop = getDiscriminatorProperty(model, discriminator, diagnostics);
+    if (!prop)
+        return undefined;
+    const keys = getStringValues(prop.type);
+    if (keys.length === 0) {
+        diagnostics.push(createDiagnostic({
+            code: "invalid-discriminator-value",
+            format: { kind: prop.type.kind },
+            target: prop,
+        }));
     }
-    let cp = sv.codePointAt(0);
-    if (!isIdentifierStart(cp)) {
-        return true;
+    return keys;
+}
+function getStringValues(type) {
+    switch (type.kind) {
+        case "String":
+            return [type.value];
+        case "Union":
+            return [...type.variants.values()].flatMap((x) => getStringValues(x.type)).filter(isDefined);
+        case "EnumMember":
+            return typeof type.value !== "number" ? [type.value ?? type.name] : [];
+        case "UnionVariant":
+            return getStringValues(type.type);
+        default:
+            return [];
+    }
+}
+function getStringValue(type) {
+    switch (type.kind) {
+        case "String":
+            return type.value;
+        case "EnumMember":
+            return typeof type.value !== "number" ? (type.value ?? type.name) : undefined;
+        default:
+            return undefined;
     }
-    let pos = 0;
-    do {
-        pos += utf16CodeUnits(cp);
-    } while (pos < sv.length && isIdentifierContinue((cp = sv.codePointAt(pos))));
-    return pos < sv.length;
 }
 
 function getTypeName(type, options) {
@@ -32040,6 +32318,7 @@ _a = Realm;
  * @internal
  */
 const TypekitPrototype = {};
+const TypekitNamespaceSymbol = Symbol.for("TypekitNamespace");
 /**
  * Defines an extension to the Typekit interface.
  *
@@ -32049,10 +32328,228 @@ const TypekitPrototype = {};
  */
 function defineKit(source) {
     for (const [name, fnOrNs] of Object.entries(source)) {
-        TypekitPrototype[name] = fnOrNs;
+        let kits = fnOrNs;
+        if (TypekitPrototype[name] !== undefined) {
+            kits = { ...TypekitPrototype[name], ...fnOrNs };
+        }
+        // Tag top-level namespace objects with the symbol
+        if (typeof kits === "object" && kits !== null) {
+            Object.defineProperty(kits, TypekitNamespaceSymbol, {
+                value: true,
+                enumerable: false, // Keep the symbol non-enumerable
+                configurable: false,
+            });
+        }
+        TypekitPrototype[name] = kits;
     }
 }
 
+defineKit({
+    array: {
+        is(type) {
+            return (type.kind === "Model" && isArrayModelType(this.program, type) && type.properties.size === 0);
+        },
+        getElementType(type) {
+            if (!this.array.is(type)) {
+                throw new Error("Type is not an array.");
+            }
+            return type.indexer.value;
+        },
+        create(elementType) {
+            return this.model.create({
+                name: "Array",
+                properties: {},
+                indexer: {
+                    key: this.builtin.integer,
+                    value: elementType,
+                },
+            });
+        },
+    },
+});
+
+defineKit({
+    builtin: {
+        get string() {
+            return this.program.checker.getStdType("string");
+        },
+        get boolean() {
+            return this.program.checker.getStdType("boolean");
+        },
+        get bytes() {
+            return this.program.checker.getStdType("bytes");
+        },
+        get decimal() {
+            return this.program.checker.getStdType("decimal");
+        },
+        get decimal128() {
+            return this.program.checker.getStdType("decimal128");
+        },
+        get duration() {
+            return this.program.checker.getStdType("duration");
+        },
+        get float() {
+            return this.program.checker.getStdType("float");
+        },
+        get float32() {
+            return this.program.checker.getStdType("float32");
+        },
+        get float64() {
+            return this.program.checker.getStdType("float64");
+        },
+        get int8() {
+            return this.program.checker.getStdType("int8");
+        },
+        get int16() {
+            return this.program.checker.getStdType("int16");
+        },
+        get int32() {
+            return this.program.checker.getStdType("int32");
+        },
+        get int64() {
+            return this.program.checker.getStdType("int64");
+        },
+        get integer() {
+            return this.program.checker.getStdType("integer");
+        },
+        get offsetDateTime() {
+            return this.program.checker.getStdType("offsetDateTime");
+        },
+        get plainDate() {
+            return this.program.checker.getStdType("plainDate");
+        },
+        get plainTime() {
+            return this.program.checker.getStdType("plainTime");
+        },
+        get safeInt() {
+            return this.program.checker.getStdType("safeint");
+        },
+        get uint8() {
+            return this.program.checker.getStdType("uint8");
+        },
+        get uint16() {
+            return this.program.checker.getStdType("uint16");
+        },
+        get uint32() {
+            return this.program.checker.getStdType("uint32");
+        },
+        get uint64() {
+            return this.program.checker.getStdType("uint64");
+        },
+        get url() {
+            return this.program.checker.getStdType("url");
+        },
+        get utcDateTime() {
+            return this.program.checker.getStdType("utcDateTime");
+        },
+        get numeric() {
+            return this.program.checker.getStdType("numeric");
+        },
+    },
+});
+
+/**
+ * Creates a shallow copy of a rekeyable map.
+ *
+ * @experimental
+ */
+function copyMap(map) {
+    return createRekeyableMap(map.entries());
+}
+/**
+ * Utility function for converting a list of decorators and arguments into structure decorator applications that are
+ * compatible with the TypeSpec type graph.
+ *
+ * Note: Not all JavaScript values can be converted faithfully to TypeSpec values. This function will attempt to convert
+ * the value to a literal TypeSpec value if it is a primitive value, otherwise it will be left as a JavaScript value.
+ * The `jsValue` property of the argument will always contain the original JavaScript value passed to the decorator.
+ *
+ * @param typekit - The Typekit instance to use for creating types and values.
+ * @param decorators - The list of decorators and arguments to apply.
+ *
+ * @see {@link DecoratorArgs}
+ *
+ * @experimental
+ */
+function decoratorApplication(typekit, decorators) {
+    return (decorators?.map((arg) => {
+        const [decorator, args] = Array.isArray(arg) ? [arg[0], arg.slice(1)] : [arg, []];
+        return {
+            decorator,
+            args: args.map((rawValue) => ({
+                value: typeof rawValue === "object" && rawValue !== null
+                    ? rawValue
+                    : typekit.literal.create(rawValue),
+                jsValue: rawValue,
+            })),
+        };
+    }) ?? []);
+}
+
+defineKit({
+    enumMember: {
+        create(desc) {
+            const member = this.program.checker.createType({
+                kind: "EnumMember",
+                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);
+            return member;
+        },
+        is(type) {
+            return type.kind === "EnumMember";
+        },
+    },
+});
+
+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 });
+        },
+    },
+});
+
 defineKit({
     literal: {
         create(value) {
@@ -32172,6 +32669,63 @@ function getVisibilityForClass(program, property, visibilityClass) {
 }
 // #endregion
 
+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;
+}
+
 /**
  * Flow control for mutators.
  *
@@ -32199,6 +32753,7 @@ var MutatorFlow;
 })(MutatorFlow || (MutatorFlow = {}));
 // #endregion
 
+const [getSummary, setSummary] = useStateMap(createStateSymbol("summary"));
 /**
  * Get the documentation string for the given type.
  * @param program Program
@@ -32226,47 +32781,21 @@ defineKit({
         getVisibilityForClass(property, visibilityClass) {
             return getVisibilityForClass(this.program, property, visibilityClass);
         },
+        create(desc) {
+            return this.program.checker.createType({
+                kind: "ModelProperty",
+                name: desc.name,
+                node: undefined,
+                type: desc.type,
+                optional: desc.optional ?? false,
+                decorators: [],
+                defaultValue: desc.defaultValue,
+            });
+        },
     },
 });
 
-/**
- * Creates a shallow copy of a rekeyable map.
- *
- * @experimental
- */
-function copyMap(map) {
-    return createRekeyableMap(map.entries());
-}
-/**
- * Utility function for converting a list of decorators and arguments into structure decorator applications that are
- * compatible with the TypeSpec type graph.
- *
- * Note: Not all JavaScript values can be converted faithfully to TypeSpec values. This function will attempt to convert
- * the value to a literal TypeSpec value if it is a primitive value, otherwise it will be left as a JavaScript value.
- * The `jsValue` property of the argument will always contain the original JavaScript value passed to the decorator.
- *
- * @param typekit - The Typekit instance to use for creating types and values.
- * @param decorators - The list of decorators and arguments to apply.
- *
- * @see {@link DecoratorArgs}
- *
- * @experimental
- */
-function decoratorApplication(typekit, decorators) {
-    return (decorators?.map((arg) => {
-        const [decorator, args] = Array.isArray(arg) ? [arg[0], arg.slice(1)] : [arg, []];
-        return {
-            decorator,
-            args: args.map((rawValue) => ({
-                value: typeof rawValue === "object" && rawValue !== null
-                    ? rawValue
-                    : typekit.literal.create(rawValue),
-                jsValue: rawValue,
-            })),
-        };
-    }) ?? []);
-}
-
+const spreadCache = new Map();
 defineKit({
     model: {
         create(desc) {
@@ -32280,6 +32809,7 @@ defineKit({
                 node: undefined,
                 derivedModels: desc.derivedModels ?? [],
                 sourceModels: desc.sourceModels ?? [],
+                indexer: desc.indexer,
             });
             this.program.checker.finishType(model);
             return model;
@@ -32287,9 +32817,105 @@ defineKit({
         is(type) {
             return type.kind === "Model";
         },
+        isExpresion(type) {
+            return type.name === "";
+        },
         getEffectiveModel(model, filter) {
             return getEffectiveModelType(this.program, model, filter);
         },
+        getSpreadType(model) {
+            if (spreadCache.has(model)) {
+                return spreadCache.get(model);
+            }
+            if (!model.indexer) {
+                return undefined;
+            }
+            if (model.indexer.key.name === "string") {
+                const record = this.record.create(model.indexer.value);
+                spreadCache.set(model, record);
+                return record;
+            }
+            if (model.indexer.key.name === "integer") {
+                const array = this.array.create(model.indexer.value);
+                spreadCache.set(model, array);
+                return array;
+            }
+            return model.indexer.value;
+        },
+        getProperties(model, options = {}) {
+            // Add explicitly defined properties
+            const properties = copyMap(model.properties);
+            // Add discriminator property if it exists
+            const discriminator = this.type.getDiscriminator(model);
+            if (discriminator) {
+                const discriminatorName = discriminator.propertyName;
+                properties.set(discriminatorName, this.modelProperty.create({ name: discriminatorName, type: this.builtin.string }));
+            }
+            if (options.includeExtended) {
+                let base = model.baseModel;
+                while (base) {
+                    for (const [key, value] of base.properties) {
+                        if (!properties.has(key)) {
+                            properties.set(key, value);
+                        }
+                    }
+                    base = base.baseModel;
+                }
+            }
+            // TODO: Add Spread?
+            return properties;
+        },
+    },
+});
+
+defineKit({
+    operation: {
+        is(type) {
+            return type.kind === "Operation";
+        },
+        create(desc) {
+            const parametersModel = this.model.create({
+                name: `${desc.name}Parameters`,
+                properties: desc.parameters.reduce((acc, property) => {
+                    acc[property.name] = property;
+                    return acc;
+                }, {}),
+            });
+            const operation = this.program.checker.createType({
+                kind: "Operation",
+                name: desc.name,
+                decorators: [],
+                parameters: parametersModel,
+                returnType: desc.returnType,
+                node: undefined,
+            });
+            this.program.checker.finishType(operation);
+            return operation;
+        },
+    },
+});
+
+defineKit({
+    record: {
+        is(type) {
+            return (type.kind === "Model" && isRecordModelType(this.program, type) && type.properties.size === 0);
+        },
+        getElementType(type) {
+            if (!this.record.is(type)) {
+                throw new Error("Type is not a record.");
+            }
+            return type.indexer.value;
+        },
+        create(elementType) {
+            return this.model.create({
+                name: "Record",
+                properties: {},
+                indexer: {
+                    key: this.builtin.string,
+                    value: elementType,
+                },
+            });
+        },
     },
 });
 
@@ -32381,6 +33007,22 @@ function extendsStdType(typeName) {
     };
 }
 
+/**
+ * Get a plausible name for the given type.
+ * @experimental
+ */
+function getPlausibleName(type) {
+    let name = type.name;
+    if (!name) {
+        name = "TypeExpression"; // TODO: Implement automatic name generation based on the type context
+    }
+    if (isTemplateInstance(type)) {
+        const namePrefix = type.templateMapper.args.map((a) => ("name" in a && a.name) || "").join("_");
+        name = `${namePrefix}${name}`;
+    }
+    return name;
+}
+
 defineKit({
     type: {
         finishType(type) {
@@ -32460,6 +33102,66 @@ defineKit({
             this.realm.addType(clone);
             return clone;
         },
+        isError(type) {
+            return isErrorType(type);
+        },
+        getEncodedName(type, encoding) {
+            return resolveEncodedName(this.program, type, encoding);
+        },
+        getSummary(type) {
+            return getSummary(this.program, type);
+        },
+        getDoc(type) {
+            return getDoc(this.program, type);
+        },
+        getPlausibleName(type) {
+            return getPlausibleName(type);
+        },
+        getDiscriminator(type) {
+            return getDiscriminator(this.program, type);
+        },
+        getDiscriminatedUnion(type) {
+            const discriminator = getDiscriminator(this.program, type);
+            if (!discriminator) {
+                return undefined;
+            }
+            const [union] = getDiscriminatedUnion(type, discriminator);
+            const variants = Array.from(union.variants.entries()).map(([k, v]) => this.unionVariant.create({ name: k, type: v }));
+            return this.union.create({
+                name: union.propertyName,
+                variants,
+            });
+        },
+        maxValue(type) {
+            return getMaxValue(this.program, type);
+        },
+        minValue(type) {
+            return getMinValue(this.program, type);
+        },
+        maxLength(type) {
+            return getMaxLength(this.program, type);
+        },
+        minLength(type) {
+            return getMinLength(this.program, type);
+        },
+        maxItems(type) {
+            return getMaxItems(this.program, type);
+        },
+        maxValueExclusive(type) {
+            return getMaxValueExclusive(this.program, type);
+        },
+        minValueExclusive(type) {
+            return getMinValueExclusive(this.program, type);
+        },
+        minItems(type) {
+            return getMinItems(this.program, type);
+        },
+        isNever(type) {
+            return isNeverType(type);
+        },
+        isUserDefined(type) {
+            return getLocationContext(this.program, type).type === "project";
+        },
     },
 });
 
@@ -32485,6 +33187,10 @@ defineKit({
 
 defineKit({
     union: {
+        filter(union, filterFn) {
+            const variants = Array.from(union.variants.values()).filter(filterFn);
+            return this.union.create({ variants });
+        },
         create(desc) {
             const union = this.program.checker.createType({
                 kind: "Union",
@@ -32545,6 +33251,88 @@ defineKit({
             }
             return false;
         },
+        isExpression(type) {
+            return type.name === undefined || type.name === "";
+        },
+    },
+});
+
+defineKit({
+    value: {
+        is(value) {
+            const type = value;
+            return (this.value.isString(type) ||
+                this.value.isNumeric(type) ||
+                this.value.isBoolean(type) ||
+                this.value.isArray(type) ||
+                this.value.isObject(type) ||
+                this.value.isEnum(type) ||
+                this.value.isNull(type) ||
+                this.value.isScalar(type));
+        },
+        create(value) {
+            if (typeof value === "string") {
+                return this.value.createString(value);
+            }
+            else if (typeof value === "number") {
+                return this.value.createNumeric(value);
+            }
+            else {
+                return this.value.createBoolean(value);
+            }
+        },
+        createString(value) {
+            return {
+                entityKind: "Value",
+                value: value,
+                valueKind: "StringValue",
+                type: this.literal.createString(value),
+                scalar: undefined,
+            };
+        },
+        createNumeric(value) {
+            const valueAsString = String(value);
+            return {
+                entityKind: "Value",
+                value: Numeric(valueAsString),
+                valueKind: "NumericValue",
+                type: this.literal.createNumeric(value),
+                scalar: undefined,
+            };
+        },
+        createBoolean(value) {
+            return {
+                entityKind: "Value",
+                value: value,
+                valueKind: "BooleanValue",
+                type: this.literal.createBoolean(value),
+                scalar: undefined,
+            };
+        },
+        isBoolean(type) {
+            return type.valueKind === "BooleanValue";
+        },
+        isString(type) {
+            return type.valueKind === "StringValue";
+        },
+        isNumeric(type) {
+            return type.valueKind === "NumericValue";
+        },
+        isArray(type) {
+            return type.valueKind === "ArrayValue";
+        },
+        isObject(type) {
+            return type.valueKind === "ObjectValue";
+        },
+        isEnum(type) {
+            return type.valueKind === "EnumValue";
+        },
+        isNull(type) {
+            return type.valueKind === "NullValue";
+        },
+        isScalar(type) {
+            return type.valueKind === "ScalarValue";
+        },
     },
 });
 
@@ -32571,13 +33359,15 @@ function createTypekit(realm) {
                 return realm;
             }
             const value = Reflect.get(target, prop, receiver);
+            // Wrap functions to set `this` correctly
             if (typeof value === "function") {
                 return function (...args) {
                     return value.apply(proxy, args);
                 };
             }
-            if (typeof value === "object" && value !== null) {
-                return new Proxy(value, handler);
+            // Only wrap objects marked as Typekit namespaces
+            if (typeof value === "object" && value !== null && isTypekitNamespace(value)) {
+                return new Proxy(value, handler); // Wrap namespace objects
             }
             return value;
         },
@@ -32585,6 +33375,10 @@ function createTypekit(realm) {
     const proxy = new Proxy(tk, handler);
     return proxy;
 }
+// Helper function to check if an object is a Typekit namespace
+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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/html-program-viewer",
-  "version": "0.65.0",
+  "version": "0.66.0-dev.1",
   "author": "Microsoft Corporation",
   "description": "TypeSpec library for emitting an html view of the program.",
   "homepage": "https://typespec.io",
@@ -36,7 +36,7 @@
     "!dist/test/**"
   ],
   "peerDependencies": {
-    "@typespec/compiler": "~0.65.0"
+    "@typespec/compiler": "~0.65.1 || >=0.66.0-dev <0.66.0"
   },
   "dependencies": {
     "@fluentui/react-components": "~9.57.0",
@@ -54,6 +54,7 @@
     "@types/node": "~22.10.10",
     "@types/react": "~18.3.11",
     "@types/react-dom": "~18.3.0",
+    "@typespec/compiler": "~0.65.1 || >=0.66.0-dev <0.66.0",
     "@vitejs/plugin-react": "~4.3.4",
     "@vitest/coverage-v8": "^3.0.4",
     "@vitest/ui": "^3.0.3",
@@ -64,7 +65,7 @@
     "vite-plugin-checker": "^0.8.0",
     "vite-plugin-dts": "4.5.0",
     "vitest": "^3.0.5",
-    "@typespec/compiler": "~0.65.0",
+    "vite-plugin-node-polyfills": "^0.23.0",
     "@typespec/react-components": "~0.57.0"
   },
   "scripts": {

package/dist/manifest-BNuBm9Cd.js

@@ -1,6 +0,0 @@
-const manifest = {
-  "version": "0.65.0",
-  "commit": "ef04080e69155401e5047cff69e5b50c1844d5dc"
-};
-
-export { manifest as default };