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

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-CoFoVY97.js')).default;
+    manifest = (await import('../manifest-BeToQ_PI.js')).default;
 }
 catch {
     const name = "../dist/manifest.js";
@@ -17861,6 +17861,87 @@ function isDefined(arg) {
 function mutate(value) {
     return value;
 }
+function createRekeyableMap(entries) {
+    return new RekeyableMapImpl(entries);
+}
+class RekeyableMapImpl {
+    #keys = new Map();
+    #values = new Map();
+    constructor(entries) {
+        if (entries) {
+            for (const [key, value] of entries) {
+                this.set(key, value);
+            }
+        }
+    }
+    clear() {
+        this.#keys.clear();
+        this.#values.clear();
+    }
+    delete(key) {
+        const keyItem = this.#keys.get(key);
+        if (keyItem) {
+            this.#keys.delete(key);
+            return this.#values.delete(keyItem);
+        }
+        return false;
+    }
+    forEach(callbackfn, thisArg) {
+        this.#values.forEach((value, keyItem) => {
+            callbackfn(value, keyItem.key, this);
+        }, thisArg);
+    }
+    get(key) {
+        const keyItem = this.#keys.get(key);
+        return keyItem ? this.#values.get(keyItem) : undefined;
+    }
+    has(key) {
+        return this.#keys.has(key);
+    }
+    set(key, value) {
+        let keyItem = this.#keys.get(key);
+        if (!keyItem) {
+            keyItem = { key };
+            this.#keys.set(key, keyItem);
+        }
+        this.#values.set(keyItem, value);
+        return this;
+    }
+    get size() {
+        return this.#values.size;
+    }
+    *entries() {
+        for (const [k, v] of this.#values) {
+            yield [k.key, v];
+        }
+    }
+    *keys() {
+        for (const k of this.#values.keys()) {
+            yield k.key;
+        }
+    }
+    values() {
+        return this.#values.values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = "RekeyableMap";
+    rekey(existingKey, newKey) {
+        const keyItem = this.#keys.get(existingKey);
+        if (!keyItem) {
+            return false;
+        }
+        this.#keys.delete(existingKey);
+        const newKeyItem = this.#keys.get(newKey);
+        if (newKeyItem) {
+            this.#values.delete(newKeyItem);
+        }
+        keyItem.key = newKey;
+        this.#keys.set(newKey, keyItem);
+        return true;
+    }
+}
 
 /**
  * Create a new diagnostics creator.
@@ -18065,12 +18146,6 @@ const diagnostics = {
             typeofTarget: "Typeof expects a value literal or value reference.",
         },
     },
-    "trailing-token": {
-        severity: "error",
-        messages: {
-            default: paramMessage `Trailing ${"token"}`,
-        },
-    },
     "unknown-directive": {
         severity: "error",
         messages: {
@@ -18689,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: {
@@ -18914,6 +18995,26 @@ const diagnostics = {
             default: "Conflict marker encountered.",
         },
     },
+    // #region Visibility
+    "visibility-sealed": {
+        severity: "error",
+        messages: {
+            default: paramMessage `Visibility of property '${"propName"}' is sealed and cannot be changed.`,
+        },
+    },
+    "visibility-mixed-legacy": {
+        severity: "error",
+        messages: {
+            default: "Cannot apply both string (legacy) visibility modifiers and enum-based visibility modifiers to a property.",
+        },
+    },
+    "default-visibility-not-member": {
+        severity: "error",
+        messages: {
+            default: "The default visibility modifiers of a class must be members of the class enum.",
+        },
+    },
+    // #endregion
     // #region CLI
     "no-compatible-vs-installed": {
         severity: "error",
@@ -22671,8 +22772,7 @@ function serialize (cmpts, opts) {
   }
 
   if (options.reference !== 'suffix' && components.scheme) {
-    uriTokens.push(components.scheme);
-    uriTokens.push(':');
+    uriTokens.push(components.scheme, ':');
   }
 
   const authority = recomposeAuthority(components, options);
@@ -22702,13 +22802,11 @@ function serialize (cmpts, opts) {
   }
 
   if (components.query !== undefined) {
-    uriTokens.push('?');
-    uriTokens.push(components.query);
+    uriTokens.push('?', components.query);
   }
 
   if (components.fragment !== undefined) {
-    uriTokens.push('#');
-    uriTokens.push(components.fragment);
+    uriTokens.push('#', components.fragment);
   }
   return uriTokens.join('')
 }
@@ -22806,9 +22904,6 @@ function parse$2 (uri, opts) {
       if (gotEncoding && parsed.scheme !== undefined) {
         parsed.scheme = unescape(parsed.scheme);
       }
-      if (gotEncoding && parsed.userinfo !== undefined) {
-        parsed.userinfo = unescape(parsed.userinfo);
-      }
       if (gotEncoding && parsed.host !== undefined) {
         parsed.host = unescape(parsed.host);
       }
@@ -27603,6 +27698,14 @@ function compilerAssert(condition, message, target) {
     }
     throw new Error(message);
 }
+/**
+ * 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.
+ * @returns Actual result.
+ */
+function ignoreDiagnostics(result) {
+    return result[0];
+}
 
 function absolutePathStatus(path) {
     if (path.startsWith(".") || !isPathAbsolute(path)) {
@@ -27831,22 +27934,22 @@ createJSONSchemaValidator(TypeSpecConfigJsonSchema);
 
 // Contains all intrinsic data setter or getter
 // Anything that the TypeSpec check might should be here.
-function createStateSymbol(name) {
+function createStateSymbol$1(name) {
     return Symbol.for(`TypeSpec.${name}`);
 }
 const stateKeys = {
-    minValues: createStateSymbol("minValues"),
-    maxValues: createStateSymbol("maxValues"),
-    minValueExclusive: createStateSymbol("minValueExclusive"),
-    maxValueExclusive: createStateSymbol("maxValueExclusive"),
-    minLength: createStateSymbol("minLengthValues"),
-    maxLength: createStateSymbol("maxLengthValues"),
-    minItems: createStateSymbol("minItems"),
-    maxItems: createStateSymbol("maxItems"),
-    docs: createStateSymbol("docs"),
-    returnDocs: createStateSymbol("returnsDocs"),
-    errorsDocs: createStateSymbol("errorDocs"),
-    discriminator: createStateSymbol("discriminator"),
+    minValues: createStateSymbol$1("minValues"),
+    maxValues: createStateSymbol$1("maxValues"),
+    minValueExclusive: createStateSymbol$1("minValueExclusive"),
+    maxValueExclusive: createStateSymbol$1("maxValueExclusive"),
+    minLength: createStateSymbol$1("minLengthValues"),
+    maxLength: createStateSymbol$1("maxLengthValues"),
+    minItems: createStateSymbol$1("minItems"),
+    maxItems: createStateSymbol$1("maxItems"),
+    docs: createStateSymbol$1("docs"),
+    returnDocs: createStateSymbol$1("returnsDocs"),
+    errorsDocs: createStateSymbol$1("errorDocs"),
+    discriminator: createStateSymbol$1("discriminator"),
 };
 function getDocKey(target) {
     switch (target) {
@@ -28904,7 +29007,6 @@ var ListKind;
     const PropertiesBase = {
         allowEmpty: true,
         toleratedDelimiterIsValid: true,
-        trailingDelimiterIsValid: true,
         allowedStatementKeyword: Token.None,
     };
     ListKind.OperationParameters = {
@@ -28970,7 +29072,6 @@ var ListKind;
         delimiter: Token.Comma,
         toleratedDelimiter: Token.Semicolon,
         toleratedDelimiterIsValid: false,
-        trailingDelimiterIsValid: false,
         invalidAnnotationTarget: "expression",
         allowedStatementKeyword: Token.None,
     };
@@ -29508,6 +29609,10 @@ var ResolutionKind;
     ResolutionKind[ResolutionKind["Constraint"] = 3] = "Constraint";
 })(ResolutionKind || (ResolutionKind = {}));
 
+function isIntrinsicType(program, type, kind) {
+    return ignoreDiagnostics(program.checker.isTypeAssignableTo(type.projectionBase ?? type, program.checker.getStdType(kind), type));
+}
+
 var yu=Object.create;var He=Object.defineProperty;var Au=Object.getOwnPropertyDescriptor;var Bu=Object.getOwnPropertyNames;var wu=Object.getPrototypeOf,xu=Object.prototype.hasOwnProperty;var sr=e=>{throw TypeError(e)};var _u=(e,t)=>()=>(e&&(t=e(e=0)),t);var At=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),We=(e,t)=>{for(var r in t)He(e,r,{get:t[r],enumerable:!0});},ar=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Bu(t))!xu.call(e,o)&&o!==r&&He(e,o,{get:()=>t[o],enumerable:!(n=Au(t,o))||n.enumerable});return e};var Me=(e,t,r)=>(r=e!=null?yu(wu(e)):{},ar(He(r,"default",{value:e,enumerable:!0}),e)),vu=e=>ar(He({},"__esModule",{value:!0}),e);var bu=(e,t,r)=>t.has(e)||sr("Cannot "+r);var Dr=(e,t,r)=>t.has(e)?sr("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(e):t.set(e,r);var pe=(e,t,r)=>(bu(e,t,"access private method"),r);var it=At((ia,sn)=>{var on=new Proxy(String,{get:()=>on});sn.exports=on;});var Tn={};We(Tn,{default:()=>_o,shouldHighlight:()=>xo});var xo,_o,kn=_u(()=>{xo=()=>!1,_o=String;});var Pn=At((bD,Xt)=>{var g=String,Ln=function(){return {isColorSupported:!1,reset:g,bold:g,dim:g,italic:g,underline:g,inverse:g,hidden:g,strikethrough:g,black:g,red:g,green:g,yellow:g,blue:g,magenta:g,cyan:g,white:g,gray:g,bgBlack:g,bgRed:g,bgGreen:g,bgYellow:g,bgBlue:g,bgMagenta:g,bgCyan:g,bgWhite:g}};Xt.exports=Ln();Xt.exports.createColors=Ln;});var $n=At(Ct=>{Object.defineProperty(Ct,"__esModule",{value:!0});Ct.codeFrameColumns=Mn;Ct.default=To;var In=(kn(),vu(Tn)),Hn=vo(Pn(),!0);function Wn(e){if(typeof WeakMap!="function")return null;var t=new WeakMap,r=new WeakMap;return (Wn=function(n){return n?r:t})(e)}function vo(e,t){if(e===null||typeof e!="object"&&typeof e!="function")return {default:e};var r=Wn(t);if(r&&r.has(e))return r.get(e);var n={__proto__:null},o=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if(u!=="default"&&{}.hasOwnProperty.call(e,u)){var i=o?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,r&&r.set(e,n),n}var bo=Hn.default,Rn=(e,t)=>r=>e(t(r)),Zt;function Oo(e){if(e){return (Zt)!=null||(Zt=(0, Hn.createColors)(!0)),Zt}return bo}var Yn=!1;function So(e){return {gutter:e.gray,marker:Rn(e.red,e.bold),message:Rn(e.red,e.bold)}}var jn=/\r\n|[\n\r\u2028\u2029]/;function No(e,t,r){let n=Object.assign({column:0,line:-1},e.start),o=Object.assign({},n,e.end),{linesAbove:u=2,linesBelow:i=3}=r||{},s=n.line,a=n.column,D=o.line,l=o.column,d=Math.max(s-(u+1),0),f=Math.min(t.length,D+i);s===-1&&(d=0),D===-1&&(f=t.length);let p=D-s,c={};if(p)for(let F=0;F<=p;F++){let m=F+s;if(!a)c[m]=!0;else if(F===0){let E=t[m-1].length;c[m]=[a,E-a+1];}else if(F===p)c[m]=[0,l];else {let E=t[m-F].length;c[m]=[0,E];}}else a===l?a?c[s]=[a,0]:c[s]=!0:c[s]=[a,l-a];return {start:d,end:f,markerLines:c}}function Mn(e,t,r={}){let n=(r.highlightCode||r.forceColor)&&(0, In.shouldHighlight)(r),o=Oo(r.forceColor),u=So(o),i=(F,m)=>n?F(m):m,s=e.split(jn),{start:a,end:D,markerLines:l}=No(t,s,r),d=t.start&&typeof t.start.column=="number",f=String(D).length,c=(n?(0, In.default)(e,r):e).split(jn,D).slice(a,D).map((F,m)=>{let E=a+1+m,w=` ${` ${E}`.slice(-f)} |`,h=l[E],C=!l[E+1];if(h){let k="";if(Array.isArray(h)){let v=F.slice(0,Math.max(h[0]-1,0)).replace(/[^\t]/g," "),$=h[1]||1;k=[`
  `,i(u.gutter,w.replace(/\d/g," "))," ",v,i(u.marker,"^").repeat($)].join(""),C&&r.message&&(k+=" "+i(u.message,r.message));}return [i(u.marker,">"),i(u.gutter,w),F.length>0?` ${F}`:"",k].join("")}else return ` ${i(u.gutter,w)}${F.length>0?` ${F}`:""}`}).join(`
 `);return r.message&&!d&&(c=`${" ".repeat(f+1)}${r.message}
@@ -30820,24 +30925,798 @@ new Set([
     "intrinsic",
 ]);
 
-let currentProgram;
-/** @experimental */
+var _a$1;
+/**
+ * A Realm's view of a Program's state map for a given state key.
+ *
+ * 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.
+ *
+ * @experimental
+ */
+class StateMapRealmView {
+    #realm;
+    #parentState;
+    #realmState;
+    constructor(realm, realmState, parentState) {
+        this.#realm = realm;
+        this.#parentState = parentState;
+        this.#realmState = realmState;
+    }
+    has(t) {
+        return this.#select(t).has(t) ?? false;
+    }
+    set(t, v) {
+        this.#select(t).set(t, v);
+        return this;
+    }
+    get(t) {
+        return this.#select(t).get(t);
+    }
+    delete(t) {
+        return this.#select(t).delete(t);
+    }
+    forEach(cb, thisArg) {
+        for (const item of this.entries()) {
+            cb.call(thisArg, item[1], item[0], this);
+        }
+        return this;
+    }
+    get size() {
+        return this.#realmState.size + this.#parentState.size;
+    }
+    clear() {
+        this.#realmState.clear();
+    }
+    *entries() {
+        for (const item of this.#realmState) {
+            yield item;
+        }
+        for (const item of this.#parentState) {
+            yield item;
+        }
+        return undefined;
+    }
+    *values() {
+        for (const item of this.entries()) {
+            yield item[1];
+        }
+        return undefined;
+    }
+    *keys() {
+        for (const item of this.entries()) {
+            yield item[0];
+        }
+        return undefined;
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    [Symbol.toStringTag] = "StateMap";
+    #select(keyType) {
+        if (this.#realm.hasType(keyType)) {
+            return this.#realmState;
+        }
+        return this.#parentState;
+    }
+}
+/**
+ * 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;
+    /**
+     * Stores all types owned by this realm.
+     */
+    #types = new Set();
+    /**
+     * 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 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) {
+            m = new Map();
+            this.#stateMaps.set(stateKey, m);
+        }
+        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);
+        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 = this.typekit.type.clone(type);
+        this.#types.add(clone);
+        _a$1.realmForType.set(clone, this);
+        return clone;
+    }
+    static #knownRealms = new Map();
+    static realmForKey(key, parentRealm) {
+        return this.#knownRealms.get(key);
+    }
+    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) {
+            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));
+        },
+    },
+});
+
 /** @experimental */
-function createTypekit() {
-    const tk = Object.create(TypekitPrototype);
-    Object.defineProperty(tk, "program", {
-        get() {
-            return currentProgram;
+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) {
+            return type.kind === "ModelProperty";
         },
-    });
+        getEncoding(type) {
+            return getEncode(this.program, type) ?? getEncode(this.program, type.type);
+        },
+        getFormat(type) {
+            return getFormat(this.program, type) ?? getFormat(this.program, type.type);
+        },
+        getVisibilityForClass(property, visibilityClass) {
+            return getVisibilityForClass(this.program, property, visibilityClass);
+        },
+    },
+});
+
+/**
+ * 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({
+    model: {
+        create(desc) {
+            const properties = createRekeyableMap(Array.from(Object.entries(desc.properties)));
+            const model = this.program.checker.createType({
+                kind: "Model",
+                name: desc.name ?? "",
+                decorators: decoratorApplication(this, desc.decorators),
+                properties: properties,
+                expression: desc.name === undefined,
+                node: undefined,
+                derivedModels: desc.derivedModels ?? [],
+                sourceModels: desc.sourceModels ?? [],
+            });
+            this.program.checker.finishType(model);
+            return model;
+        },
+        is(type) {
+            return type.kind === "Model";
+        },
+    },
+});
+
+defineKit({
+    scalar: {
+        is(type) {
+            return type.kind === "Scalar";
+        },
+        extendsBoolean: extendsStdType("boolean"),
+        extendsBytes: extendsStdType("bytes"),
+        extendsDecimal: extendsStdType("decimal"),
+        extendsDecimal128: extendsStdType("decimal128"),
+        extendsDuration: extendsStdType("duration"),
+        extendsFloat: extendsStdType("float"),
+        extendsFloat32: extendsStdType("float32"),
+        extendsFloat64: extendsStdType("float64"),
+        extendsInt8: extendsStdType("int8"),
+        extendsInt16: extendsStdType("int16"),
+        extendsInt32: extendsStdType("int32"),
+        extendsInt64: extendsStdType("int64"),
+        extendsInteger: extendsStdType("integer"),
+        extendsNumeric: extendsStdType("numeric"),
+        extendsOffsetDateTime: extendsStdType("offsetDateTime"),
+        extendsPlainDate: extendsStdType("plainDate"),
+        extendsPlainTime: extendsStdType("plainTime"),
+        extendsSafeint: extendsStdType("safeint"),
+        extendsString: extendsStdType("string"),
+        extendsUint8: extendsStdType("uint8"),
+        extendsUint16: extendsStdType("uint16"),
+        extendsUint32: extendsStdType("uint32"),
+        extendsUint64: extendsStdType("uint64"),
+        extendsUrl: extendsStdType("url"),
+        extendsUtcDateTime: extendsStdType("utcDateTime"),
+        isBoolean: isStdType("boolean"),
+        isBytes: isStdType("bytes"),
+        isDecimal: isStdType("decimal"),
+        isDecimal128: isStdType("decimal128"),
+        isDuration: isStdType("duration"),
+        isFloat: isStdType("float"),
+        isFloat32: isStdType("float32"),
+        isFloat64: isStdType("float64"),
+        isInt8: isStdType("int8"),
+        isInt16: isStdType("int16"),
+        isInt32: isStdType("int32"),
+        isInt64: isStdType("int64"),
+        isInteger: isStdType("integer"),
+        isNumeric: isStdType("numeric"),
+        isOffsetDateTime: isStdType("offsetDateTime"),
+        isPlainDate: isStdType("plainDate"),
+        isPlainTime: isStdType("plainTime"),
+        isSafeint: isStdType("safeint"),
+        isString: isStdType("string"),
+        isUint8: isStdType("uint8"),
+        isUint16: isStdType("uint16"),
+        isUint32: isStdType("uint32"),
+        isUint64: isStdType("uint64"),
+        isUrl: isStdType("url"),
+        isUtcDateTime: isStdType("utcDateTime"),
+        getStdBase(type) {
+            const tspNamespace = this.program.resolveTypeReference("TypeSpec")[0];
+            let current = type;
+            while (current) {
+                if (current.namespace === tspNamespace) {
+                    return current;
+                }
+                current = current.baseScalar;
+            }
+            return null;
+        },
+        getEncoding(type) {
+            return getEncode(this.program, type);
+        },
+        getFormat(type) {
+            return getFormat(this.program, type);
+        },
+    },
+});
+function isStdType(typeName) {
+    return function (type) {
+        return type === this.program.checker.getStdType(typeName);
+    };
+}
+function extendsStdType(typeName) {
+    return function (type) {
+        if (!this.scalar.is(type)) {
+            return false;
+        }
+        return isIntrinsicType(this.program, type, typeName);
+    };
+}
+
+defineKit({
+    type: {
+        finishType(type) {
+            this.program.checker.finishType(type);
+        },
+        clone(type) {
+            let clone;
+            switch (type.kind) {
+                case "Model":
+                    clone = this.program.checker.createType({
+                        ...type,
+                        decorators: [...type.decorators],
+                        properties: copyMap(type.properties),
+                        indexer: type.indexer ? { ...type.indexer } : undefined,
+                    });
+                    break;
+                case "Union":
+                    clone = this.program.checker.createType({
+                        ...type,
+                        decorators: [...type.decorators],
+                        variants: copyMap(type.variants),
+                        get options() {
+                            return Array.from(this.variants.values()).map((v) => v.type);
+                        },
+                    });
+                    break;
+                case "Interface":
+                    clone = this.program.checker.createType({
+                        ...type,
+                        decorators: [...type.decorators],
+                        operations: copyMap(type.operations),
+                    });
+                    break;
+                case "Enum":
+                    clone = this.program.checker.createType({
+                        ...type,
+                        members: copyMap(type.members),
+                    });
+                    break;
+                case "Namespace":
+                    clone = this.program.checker.createType({
+                        ...type,
+                        decorators: [...type.decorators],
+                        instantiationParameters: type.instantiationParameters
+                            ? [...type.instantiationParameters]
+                            : undefined,
+                        projections: [...type.projections],
+                    });
+                    const clonedNamespace = clone;
+                    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.interfaces = cloneTypeCollection(this, type.interfaces, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.namespaces = cloneTypeCollection(this, type.namespaces, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.operations = cloneTypeCollection(this, type.operations, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.scalars = cloneTypeCollection(this, type.scalars, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.unions = cloneTypeCollection(this, type.unions, {
+                        namespace: clonedNamespace,
+                    });
+                    break;
+                default:
+                    clone = this.program.checker.createType({
+                        ...type,
+                        ...("decorators" in type ? { decorators: [...type.decorators] } : {}),
+                    });
+                    break;
+            }
+            this.realm.addType(clone);
+            return clone;
+        },
+    },
+});
+function cloneTypeCollection(kit, collection, options = {}) {
+    const cloneCollection = new Map();
+    for (const [key, type] of collection) {
+        const clone = kit.type.clone(type);
+        if ("namespace" in clone && options.namespace) {
+            clone.namespace = options.namespace;
+        }
+        cloneCollection.set(key, clone);
+    }
+    return cloneCollection;
+}
+
+defineKit({
+    unionVariant: {
+        create(desc) {
+            const variant = this.program.checker.createType({
+                kind: "UnionVariant",
+                name: desc.name ?? Symbol("name"),
+                decorators: decoratorApplication(this, desc.decorators),
+                type: desc.type,
+                node: undefined,
+                union: desc.union,
+            });
+            this.program.checker.finishType(variant);
+            return variant;
+        },
+        is(type) {
+            return type.kind === "UnionVariant";
+        },
+    },
+});
+
+defineKit({
+    union: {
+        create(desc) {
+            const union = this.program.checker.createType({
+                kind: "Union",
+                name: desc.name,
+                decorators: decoratorApplication(this, desc.decorators),
+                variants: createRekeyableMap(),
+                get options() {
+                    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) {
+                    union.variants.set(variant.name, variant);
+                    variant.union = union;
+                }
+            }
+            else if (desc.variants) {
+                for (const [name, value] of Object.entries(desc.variants)) {
+                    union.variants.set(name, this.unionVariant.create({ name, type: this.literal.create(value) }));
+                }
+            }
+            this.program.checker.finishType(union);
+            return union;
+        },
+        is(type) {
+            return type.kind === "Union";
+        },
+        isValidEnum(type) {
+            for (const variant of type.variants.values()) {
+                if (!this.literal.isString(variant.type) && !this.literal.isNumeric(variant.type)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+        isExtensible(type) {
+            const variants = Array.from(type.variants.values());
+            if (variants.length === 0) {
+                return false;
+            }
+            for (let i = 0; i < variants.length; i++) {
+                let isCommon = true;
+                for (let j = 0; j < variants.length; j++) {
+                    if (i === j) {
+                        continue;
+                    }
+                    const assignable = ignoreDiagnostics(this.program.checker.isTypeAssignableTo(variants[j].type, variants[i].type, type));
+                    if (!assignable) {
+                        isCommon = false;
+                        break;
+                    }
+                }
+                if (isCommon) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    },
+});
+
+/**
+ * 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 createTypekit(realm) {
+    const tk = Object.create(TypekitPrototype);
     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;
+                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);
@@ -30852,18 +31731,80 @@ function createTypekit() {
     const proxy = new Proxy(tk, handler);
     return proxy;
 }
-/** @experimental */
-createTypekit();
-
+// #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;
+}
 /**
- * Get the documentation string for the given type.
- * @param program Program
- * @param target Type
- * @returns Documentation value
+ * 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
  */
-function getDoc(program, target) {
-    return getDocDataInternal(program, target, "self")?.value;
-}
+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) {