@typespec/html-program-viewer 0.63.0-dev.1 → 0.63.0

package/dist/manifest-BeToQ_PI.js

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

package/dist/react/index.js

@@ -17820,7 +17820,7 @@ let manifest;
 try {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    manifest = (await import('../manifest-seJyOKYj.js')).default;
+    manifest = (await import('../manifest-BeToQ_PI.js')).default;
 }
 catch {
     const name = "../dist/manifest.js";
@@ -18764,6 +18764,12 @@ const diagnostics = {
     /**
      * Decorator
      */
+    "invalid-pattern-regex": {
+        severity: "warning",
+        messages: {
+            default: "@pattern decorator expects a valid regular expression pattern.",
+        },
+    },
     "decorator-wrong-target": {
         severity: "error",
         messages: {
@@ -30919,158 +30925,15 @@ new Set([
     "intrinsic",
 ]);
 
-const CURRENT_PROGRAM = Symbol.for("TypeSpec.currentProgram");
-/** @experimental */
-const TypekitPrototype = {};
-/** @experimental */
-function createTypekit() {
-    const tk = Object.create(TypekitPrototype);
-    Object.defineProperty(tk, "program", {
-        get() {
-            return globalThis[CURRENT_PROGRAM];
-        },
-    });
-    const handler = {
-        get(target, prop, receiver) {
-            const value = Reflect.get(target, prop, receiver);
-            if (prop === "program") {
-                // don't wrap program (probably need to ensure this isn't a nested program somewhere)
-                return value;
-            }
-            if (typeof value === "function") {
-                return function (...args) {
-                    return value.apply(proxy, args);
-                };
-            }
-            if (typeof value === "object" && value !== null) {
-                return new Proxy(value, handler);
-            }
-            return value;
-        },
-    };
-    const proxy = new Proxy(tk, handler);
-    return proxy;
-}
-/** @experimental */
-function defineKit(source) {
-    for (const [name, fnOrNs] of Object.entries(source)) {
-        TypekitPrototype[name] = fnOrNs;
-    }
-}
-/** @experimental */
-const $ = createTypekit();
-
-/** @experimental */
-function unsafe_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];
-}
-
-function createStateSymbol(name) {
-    return Symbol.for(`TypeSpec.${name}`);
-}
-function useStateMap(key) {
-    return unsafe_useStateMap(typeof key === "string" ? createStateSymbol(key) : key);
-}
-
-// 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("visibilityStore");
-/**
- * Returns the visibility modifiers for a given `property` within a `program`.
- */
-function getOrInitializeVisibilityModifiers(program, property) {
-    let visibilityModifiers = getVisibilityStore(program, property);
-    if (!visibilityModifiers) {
-        visibilityModifiers = new Map();
-        setVisibilityStore(program, property, visibilityModifiers);
-    }
-    return visibilityModifiers;
-}
-/**
- * Returns the active visibility modifier set for a given `property` and `visibilityClass`.
- *
- * If no visibility modifiers have been set for the given `property` and `visibilityClass`, the function will use the
- * provided `defaultSet` to initialize the visibility modifiers.
- *
- * @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
- * @param defaultSet - the default set to use if no set has been initialized
- * @returns the active visibility modifier set for the given property and visibility class
- */
-function getOrInitializeActiveModifierSetForClass(program, property, visibilityClass, defaultSet) {
-    const visibilityModifiers = getOrInitializeVisibilityModifiers(program, property);
-    let visibilityModifierSet = visibilityModifiers.get(visibilityClass);
-    if (!visibilityModifierSet) {
-        visibilityModifierSet = defaultSet;
-        visibilityModifiers.set(visibilityClass, visibilityModifierSet);
-    }
-    return visibilityModifierSet;
-}
-/**
- * Stores the default modifier set for a given visibility class.
- */
-const [getDefaultModifiers, setDefaultModifiers] = useStateMap("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 cached;
-    const defaultModifierSet = new Set(visibilityClass.members.values());
-    setDefaultModifiers(program, visibilityClass, defaultModifierSet);
-    return defaultModifierSet;
-}
-// #endregion
-// #region Visibility Analysis API
+var _a$1;
 /**
- * Returns the active visibility modifiers for a property in a given visibility class.
+ * A Realm's view of a Program's state map for a given state key.
  *
- * 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.
+ * For all operations, if a type was created within the realm, the realm's own state map is used. Otherwise, the owning'
+ * Program's state map is used.
  *
- * @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
+ * @experimental
  */
-function getVisibilityForClass(program, property, visibilityClass) {
-    return getOrInitializeActiveModifierSetForClass(program, property, visibilityClass, 
-    /* defaultSet: */ getDefaultModifierSetForClass(program, visibilityClass));
-}
-// #endregion
-
-var _a$1;
 class StateMapRealmView {
     #realm;
     #parentState;
@@ -31081,17 +30944,17 @@ class StateMapRealmView {
         this.#realmState = realmState;
     }
     has(t) {
-        return this.dispatch(t).has(t) ?? false;
+        return this.#select(t).has(t) ?? false;
     }
     set(t, v) {
-        this.dispatch(t).set(t, v);
+        this.#select(t).set(t, v);
         return this;
     }
     get(t) {
-        return this.dispatch(t).get(t);
+        return this.#select(t).get(t);
     }
     delete(t) {
-        return this.dispatch(t).delete(t);
+        return this.#select(t).delete(t);
     }
     forEach(cb, thisArg) {
         for (const item of this.entries()) {
@@ -31100,8 +30963,7 @@ class StateMapRealmView {
         return this;
     }
     get size() {
-        // extremely non-optimal, maybe worth not offering it?
-        return [...this.entries()].length;
+        return this.#realmState.size + this.#parentState.size;
     }
     clear() {
         this.#realmState.clear();
@@ -31131,17 +30993,24 @@ class StateMapRealmView {
         return this.entries();
     }
     [Symbol.toStringTag] = "StateMap";
-    dispatch(keyType) {
+    #select(keyType) {
         if (this.#realm.hasType(keyType)) {
             return this.#realmState;
         }
         return this.#parentState;
     }
 }
-/** @experimental */
+/**
+ * A Realm is an alternate view of a Program where types can be cloned, deleted, and modified without affecting the
+ * original types in the Program.
+ *
+ * The realm stores the types that exist within the realm, views of state maps that only apply within the realm,
+ * and a view of types that have been removed from the realm's view.
+ *
+ * @experimental
+ */
 class Realm {
     #program;
-    // Type registry
     /**
      * Stores all types owned by this realm.
      */
@@ -31150,14 +31019,44 @@ class Realm {
      * Stores types that are deleted in this realm. When a realm is active and doing a traversal, you will
      * not find this type in e.g. collections. Deleted types are mapped to `null` if you ask for it.
      */
-    #deletedTypes = new Set();
+    #deletedTypes = new WeakSet();
     #stateMaps = new Map();
     key;
+    /**
+     * Create a new realm in the given program.
+     *
+     * @param program - The program to create the realm in.
+     * @param description - A short description of the realm's purpose.
+     */
     constructor(program, description) {
         this.key = Symbol(description);
         this.#program = program;
         _a$1.#knownRealms.set(this.key, this);
     }
+    #_typekit;
+    /**
+     * The typekit instance bound to this realm.
+     *
+     * If the realm does not already have a typekit associated with it, one will be created and bound to this realm.
+     */
+    get typekit() {
+        return (this.#_typekit ??= createTypekit(this));
+    }
+    /**
+     * The program that this realm is associated with.
+     */
+    get program() {
+        return this.#program;
+    }
+    /**
+     * Gets a state map for the given state key symbol.
+     *
+     * This state map is a view of the program's state map for the given state key, with modifications made to the realm's
+     * own state.
+     *
+     * @param stateKey - The symbol to use as the state key.
+     * @returns The realm's state map for the given state key.
+     */
     stateMap(stateKey) {
         let m = this.#stateMaps.get(stateKey);
         if (!m) {
@@ -31166,24 +31065,50 @@ class Realm {
         }
         return new StateMapRealmView(this, m, this.#program.stateMap(stateKey));
     }
+    /**
+     * Clones a type and adds it to the realm. This operation will use the realm's typekit to clone the type.
+     *
+     * @param type - The type to clone.
+     * @returns A clone of the input type that exists within this realm.
+     */
     clone(type) {
         compilerAssert(type, "Undefined type passed to clone");
         const clone = this.#cloneIntoRealm(type);
-        $.type.finishType(clone);
+        this.typekit.type.finishType(clone);
         return clone;
     }
+    /**
+     * Removes a type from this realm. This operation will not affect the type in the program, only this realm's view
+     * of the type.
+     *
+     * @param type - The TypeSpec type to remove from this realm.
+     */
     remove(type) {
         this.#deletedTypes.add(type);
     }
+    /**
+     * Determines whether or not this realm contains a given type.
+     *
+     * @param type - The type to check.
+     * @returns true if the type was created within this realm or added to this realm, false otherwise.
+     */
     hasType(type) {
         return this.#types.has(type);
     }
+    /**
+     * Adds a type to this realm. Once a type is added to the realm, the realm considers it part of itself.
+     *
+     * A type can be present in multiple realms, but `Realm.realmForType` will only return the last realm that the type
+     * was added to.
+     *
+     * @param type - The type to add to this realm.
+     */
     addType(type) {
         this.#types.add(type);
         _a$1.realmForType.set(type, this);
     }
     #cloneIntoRealm(type) {
-        const clone = $.type.clone(type);
+        const clone = this.typekit.type.clone(type);
         this.#types.add(clone);
         _a$1.realmForType.set(clone, this);
         return clone;
@@ -31192,10 +31117,32 @@ class Realm {
     static realmForKey(key, parentRealm) {
         return this.#knownRealms.get(key);
     }
-    static realmForType = new Map();
+    static realmForType = new WeakMap();
 }
 _a$1 = Realm;
 
+/**
+ * The prototype object for Typekit instances.
+ *
+ * @see {@link defineKit}
+ *
+ * @experimental
+ * @internal
+ */
+const TypekitPrototype = {};
+/**
+ * Defines an extension to the Typekit interface.
+ *
+ * All Typekit instances will inherit the functionality defined by calls to this function.
+ *
+ * @experimental
+ */
+function defineKit(source) {
+    for (const [name, fnOrNs] of Object.entries(source)) {
+        TypekitPrototype[name] = fnOrNs;
+    }
+}
+
 defineKit({
     literal: {
         create(value) {
@@ -31245,6 +31192,156 @@ defineKit({
     },
 });
 
+/** @experimental */
+function unsafe_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];
+}
+
+function createStateSymbol(name) {
+    return Symbol.for(`TypeSpec.${name}`);
+}
+function useStateMap(key) {
+    return unsafe_useStateMap(typeof key === "string" ? createStateSymbol(key) : key);
+}
+
+// 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("visibilityStore");
+/**
+ * Returns the visibility modifiers for a given `property` within a `program`.
+ */
+function getOrInitializeVisibilityModifiers(program, property) {
+    let visibilityModifiers = getVisibilityStore(program, property);
+    if (!visibilityModifiers) {
+        visibilityModifiers = new Map();
+        setVisibilityStore(program, property, visibilityModifiers);
+    }
+    return visibilityModifiers;
+}
+/**
+ * Returns the active visibility modifier set for a given `property` and `visibilityClass`.
+ *
+ * If no visibility modifiers have been set for the given `property` and `visibilityClass`, the function will use the
+ * provided `defaultSet` to initialize the visibility modifiers.
+ *
+ * @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
+ * @param defaultSet - the default set to use if no set has been initialized
+ * @returns the active visibility modifier set for the given property and visibility class
+ */
+function getOrInitializeActiveModifierSetForClass(program, property, visibilityClass, defaultSet) {
+    const visibilityModifiers = getOrInitializeVisibilityModifiers(program, property);
+    let visibilityModifierSet = visibilityModifiers.get(visibilityClass);
+    if (!visibilityModifierSet) {
+        visibilityModifierSet = defaultSet;
+        visibilityModifiers.set(visibilityClass, visibilityModifierSet);
+    }
+    return visibilityModifierSet;
+}
+/**
+ * Stores the default modifier set for a given visibility class.
+ */
+const [getDefaultModifiers, setDefaultModifiers] = useStateMap("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 cached;
+    const defaultModifierSet = new Set(visibilityClass.members.values());
+    setDefaultModifiers(program, visibilityClass, defaultModifierSet);
+    return 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) {
+    return getOrInitializeActiveModifierSetForClass(program, property, visibilityClass, 
+    /* defaultSet: */ getDefaultModifierSetForClass(program, visibilityClass));
+}
+// #endregion
+
+/**
+ * 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
+
+/**
+ * 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("format");
+const [getEncode, setEncodeData] = useStateMap("encode");
+
 defineKit({
     modelProperty: {
         is(type) {
@@ -31262,30 +31359,42 @@ defineKit({
     },
 });
 
-/** @experimental */
+/**
+ * Creates a shallow copy of a rekeyable map.
+ *
+ * @experimental
+ */
 function copyMap(map) {
-    return createRekeyableMap(Array.from(map.entries()));
+    return createRekeyableMap(map.entries());
 }
-/** @experimental */
-function decoratorApplication(args) {
-    if (!args) {
-        return [];
-    }
-    const decorators = [];
-    for (const arg of args) {
-        decorators.push({
-            decorator: Array.isArray(arg) ? arg[0] : arg,
-            args: Array.isArray(arg)
-                ? arg.slice(1).map((rawValue) => ({
-                    value: typeof rawValue === "object" && rawValue !== null
-                        ? rawValue
-                        : $.literal.create(rawValue),
-                    jsValue: rawValue,
-                }))
-                : [],
-        });
-    }
-    return decorators;
+/**
+ * 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({
@@ -31295,7 +31404,7 @@ defineKit({
             const model = this.program.checker.createType({
                 kind: "Model",
                 name: desc.name ?? "",
-                decorators: decoratorApplication(desc.decorators),
+                decorators: decoratorApplication(this, desc.decorators),
                 properties: properties,
                 expression: desc.name === undefined,
                 node: undefined,
@@ -31311,21 +31420,6 @@ defineKit({
     },
 });
 
-let _realm;
-defineKit({
-    realm: {
-        get() {
-            if (!_realm) {
-                _realm = new Realm(this.program, " typekit realm");
-            }
-            return _realm;
-        },
-        set(realm) {
-            _realm = realm;
-        },
-    },
-});
-
 defineKit({
     scalar: {
         is(type) {
@@ -31463,27 +31557,33 @@ defineKit({
                         projections: [...type.projections],
                     });
                     const clonedNamespace = clone;
-                    clonedNamespace.decoratorDeclarations = cloneTypeCollection(type.decoratorDeclarations, {
+                    clonedNamespace.decoratorDeclarations = cloneTypeCollection(this, type.decoratorDeclarations, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.models = cloneTypeCollection(this, type.models, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.enums = cloneTypeCollection(this, type.enums, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.functionDeclarations = cloneTypeCollection(this, type.functionDeclarations, {
                         namespace: clonedNamespace,
                     });
-                    clonedNamespace.models = cloneTypeCollection(type.models, { namespace: clonedNamespace });
-                    clonedNamespace.enums = cloneTypeCollection(type.enums, { namespace: clonedNamespace });
-                    clonedNamespace.functionDeclarations = cloneTypeCollection(type.functionDeclarations, {
+                    clonedNamespace.interfaces = cloneTypeCollection(this, type.interfaces, {
                         namespace: clonedNamespace,
                     });
-                    clonedNamespace.interfaces = cloneTypeCollection(type.interfaces, {
+                    clonedNamespace.namespaces = cloneTypeCollection(this, type.namespaces, {
                         namespace: clonedNamespace,
                     });
-                    clonedNamespace.namespaces = cloneTypeCollection(type.namespaces, {
+                    clonedNamespace.operations = cloneTypeCollection(this, type.operations, {
                         namespace: clonedNamespace,
                     });
-                    clonedNamespace.operations = cloneTypeCollection(type.operations, {
+                    clonedNamespace.scalars = cloneTypeCollection(this, type.scalars, {
                         namespace: clonedNamespace,
                     });
-                    clonedNamespace.scalars = cloneTypeCollection(type.scalars, {
+                    clonedNamespace.unions = cloneTypeCollection(this, type.unions, {
                         namespace: clonedNamespace,
                     });
-                    clonedNamespace.unions = cloneTypeCollection(type.unions, { namespace: clonedNamespace });
                     break;
                 default:
                     clone = this.program.checker.createType({
@@ -31492,15 +31592,15 @@ defineKit({
                     });
                     break;
             }
-            this.realm.get().addType(clone);
+            this.realm.addType(clone);
             return clone;
         },
     },
 });
-function cloneTypeCollection(collection, options = {}) {
+function cloneTypeCollection(kit, collection, options = {}) {
     const cloneCollection = new Map();
     for (const [key, type] of collection) {
-        const clone = $.type.clone(type);
+        const clone = kit.type.clone(type);
         if ("namespace" in clone && options.namespace) {
             clone.namespace = options.namespace;
         }
@@ -31515,7 +31615,7 @@ defineKit({
             const variant = this.program.checker.createType({
                 kind: "UnionVariant",
                 name: desc.name ?? Symbol("name"),
-                decorators: decoratorApplication(desc.decorators),
+                decorators: decoratorApplication(this, desc.decorators),
                 type: desc.type,
                 node: undefined,
                 union: desc.union,
@@ -31535,7 +31635,7 @@ defineKit({
             const union = this.program.checker.createType({
                 kind: "Union",
                 name: desc.name,
-                decorators: decoratorApplication(desc.decorators),
+                decorators: decoratorApplication(this, desc.decorators),
                 variants: createRekeyableMap(),
                 get options() {
                     return Array.from(this.variants.values()).map((v) => v.type);
@@ -31594,26 +31694,117 @@ defineKit({
     },
 });
 
-/** @experimental */
-var MutatorFlow;
-(function (MutatorFlow) {
-    MutatorFlow[MutatorFlow["MutateAndRecurse"] = 0] = "MutateAndRecurse";
-    MutatorFlow[MutatorFlow["DoNotMutate"] = 1] = "DoNotMutate";
-    MutatorFlow[MutatorFlow["DoNotRecurse"] = 2] = "DoNotRecurse";
-})(MutatorFlow || (MutatorFlow = {}));
-
 /**
- * Get the documentation string for the given type.
- * @param program Program
- * @param target Type
- * @returns Documentation value
+ * Create a new Typekit that operates in the given realm.
+ *
+ * Ordinarily, you should use the default typekit `$` to manipulate types in the current program, or call `$` with a
+ * Realm or Program as the first argument if you want to work in a specific realm or in the default typekit realm of
+ * a specific program.
+ *
+ * @param realm - The realm to create the typekit in.
+ *
+ * @experimental
  */
-function getDoc(program, target) {
-    return getDocDataInternal(program, target, "self")?.value;
+function createTypekit(realm) {
+    const tk = Object.create(TypekitPrototype);
+    const handler = {
+        get(target, prop, receiver) {
+            if (prop === "program") {
+                // don't wrap program (probably need to ensure this isn't a nested program somewhere)
+                return realm.program;
+            }
+            if (prop === "realm") {
+                return realm;
+            }
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value === "function") {
+                return function (...args) {
+                    return value.apply(proxy, args);
+                };
+            }
+            if (typeof value === "object" && value !== null) {
+                return new Proxy(value, handler);
+            }
+            return value;
+        },
+    };
+    const proxy = new Proxy(tk, handler);
+    return proxy;
 }
-// -- @format decorator ---------------------
-const [getFormat, setFormat] = useStateMap("format");
-const [getEncode, setEncodeData] = useStateMap("encode");
+// #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")) {
+        // arg is a Program
+        realm = arg[DEFAULT_REALM] ??= new Realm(arg, "default typekit realm");
+    }
+    else {
+        // arg is a Realm
+        realm = arg;
+    }
+    return realm.typekit;
+}
+/**
+ * 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.
+ *
+ * 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).
+ *
+ * @example
+ * ```ts
+ * import { $ } from "@typespec/compiler/experimental";
+ *
+ * const clone = $.type.clone(inputType);
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { $, Realm } from "@typespec/compiler/experimental";
+ *
+ * const realm = new Realm(program, "my custom realm");
+ *
+ * const clone = $(realm).type.clone(inputType);
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { $ } from "@typespec/compiler/experimental";
+ *
+ * const projectedProgram = projectProgram(program, ...);
+ *
+ * const clone = $(projectedProgram).type.clone(inputType);
+ * ```
+ *
+ * @see {@link Realm}
+ *
+ * @experimental
+ */
+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);
+    },
+});
+// #endregion
 
 const globalLibraryUrlsLoadedSym = Symbol.for("TYPESPEC_LIBRARY_URLS_LOADED");
 if (globalThis[globalLibraryUrlsLoadedSym] === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/html-program-viewer",
-  "version": "0.63.0-dev.1",
+  "version": "0.63.0",
   "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.62.0 || >=0.63.0-dev <0.63.0"
+    "@typespec/compiler": "~0.63.0"
   },
   "dependencies": {
     "@fluentui/react-components": "~9.55.0",
@@ -54,7 +54,6 @@
     "@types/node": "~22.7.9",
     "@types/react": "~18.3.11",
     "@types/react-dom": "~18.3.0",
-    "@typespec/compiler": "~0.62.0 || >=0.63.0-dev <0.63.0",
     "@vitejs/plugin-react": "~4.3.2",
     "@vitest/coverage-v8": "^2.1.5",
     "@vitest/ui": "^2.1.2",
@@ -65,6 +64,7 @@
     "vite-plugin-checker": "^0.8.0",
     "vite-plugin-dts": "4.2.3",
     "vitest": "^2.1.5",
+    "@typespec/compiler": "~0.63.0",
     "@typespec/react-components": "~0.57.0"
   },
   "scripts": {

package/dist/manifest-seJyOKYj.js

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