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

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-seJyOKYj.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: {
@@ -18914,6 +18989,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 +22766,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 +22796,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 +22898,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 +27692,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 +27928,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 +29001,6 @@ var ListKind;
     const PropertiesBase = {
         allowEmpty: true,
         toleratedDelimiterIsValid: true,
-        trailingDelimiterIsValid: true,
         allowedStatementKeyword: Token.None,
     };
     ListKind.OperationParameters = {
@@ -28970,7 +29066,6 @@ var ListKind;
         delimiter: Token.Comma,
         toleratedDelimiter: Token.Semicolon,
         toleratedDelimiterIsValid: false,
-        trailingDelimiterIsValid: false,
         invalidAnnotationTarget: "expression",
         allowedStatementKeyword: Token.None,
     };
@@ -29508,6 +29603,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,7 +30919,7 @@ new Set([
     "intrinsic",
 ]);
 
-let currentProgram;
+const CURRENT_PROGRAM = Symbol.for("TypeSpec.currentProgram");
 /** @experimental */
 const TypekitPrototype = {};
 /** @experimental */
@@ -30828,7 +30927,7 @@ function createTypekit() {
     const tk = Object.create(TypekitPrototype);
     Object.defineProperty(tk, "program", {
         get() {
-            return currentProgram;
+            return globalThis[CURRENT_PROGRAM];
         },
     });
     const handler = {
@@ -30853,7 +30952,655 @@ function createTypekit() {
     return proxy;
 }
 /** @experimental */
-createTypekit();
+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
+/**
+ * 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
+
+var _a$1;
+class StateMapRealmView {
+    #realm;
+    #parentState;
+    #realmState;
+    constructor(realm, realmState, parentState) {
+        this.#realm = realm;
+        this.#parentState = parentState;
+        this.#realmState = realmState;
+    }
+    has(t) {
+        return this.dispatch(t).has(t) ?? false;
+    }
+    set(t, v) {
+        this.dispatch(t).set(t, v);
+        return this;
+    }
+    get(t) {
+        return this.dispatch(t).get(t);
+    }
+    delete(t) {
+        return this.dispatch(t).delete(t);
+    }
+    forEach(cb, thisArg) {
+        for (const item of this.entries()) {
+            cb.call(thisArg, item[1], item[0], this);
+        }
+        return this;
+    }
+    get size() {
+        // extremely non-optimal, maybe worth not offering it?
+        return [...this.entries()].length;
+    }
+    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";
+    dispatch(keyType) {
+        if (this.#realm.hasType(keyType)) {
+            return this.#realmState;
+        }
+        return this.#parentState;
+    }
+}
+/** @experimental */
+class Realm {
+    #program;
+    // Type registry
+    /**
+     * 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 Set();
+    #stateMaps = new Map();
+    key;
+    constructor(program, description) {
+        this.key = Symbol(description);
+        this.#program = program;
+        _a$1.#knownRealms.set(this.key, this);
+    }
+    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));
+    }
+    clone(type) {
+        compilerAssert(type, "Undefined type passed to clone");
+        const clone = this.#cloneIntoRealm(type);
+        $.type.finishType(clone);
+        return clone;
+    }
+    remove(type) {
+        this.#deletedTypes.add(type);
+    }
+    hasType(type) {
+        return this.#types.has(type);
+    }
+    addType(type) {
+        this.#types.add(type);
+        _a$1.realmForType.set(type, this);
+    }
+    #cloneIntoRealm(type) {
+        const clone = $.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 Map();
+}
+_a$1 = Realm;
+
+defineKit({
+    literal: {
+        create(value) {
+            if (typeof value === "string") {
+                return this.literal.createString(value);
+            }
+            else if (typeof value === "number") {
+                return this.literal.createNumeric(value);
+            }
+            else {
+                return this.literal.createBoolean(value);
+            }
+        },
+        createString(value) {
+            return this.program.checker.createType({
+                kind: "String",
+                value,
+            });
+        },
+        createNumeric(value) {
+            const valueAsString = String(value);
+            return this.program.checker.createType({
+                kind: "Number",
+                value,
+                valueAsString,
+                numericValue: Numeric(valueAsString),
+            });
+        },
+        createBoolean(value) {
+            return this.program.checker.createType({
+                kind: "Boolean",
+                value,
+            });
+        },
+        isBoolean(type) {
+            return type.kind === "Boolean";
+        },
+        isString(type) {
+            return type.kind === "String";
+        },
+        isNumeric(type) {
+            return type.kind === "Number";
+        },
+        is(type) {
+            return (this.literal.isBoolean(type) || this.literal.isNumeric(type) || this.literal.isString(type));
+        },
+    },
+});
+
+defineKit({
+    modelProperty: {
+        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);
+        },
+    },
+});
+
+/** @experimental */
+function copyMap(map) {
+    return createRekeyableMap(Array.from(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;
+}
+
+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(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";
+        },
+    },
+});
+
+let _realm;
+defineKit({
+    realm: {
+        get() {
+            if (!_realm) {
+                _realm = new Realm(this.program, " typekit realm");
+            }
+            return _realm;
+        },
+        set(realm) {
+            _realm = realm;
+        },
+    },
+});
+
+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(type.decoratorDeclarations, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.models = cloneTypeCollection(type.models, { namespace: clonedNamespace });
+                    clonedNamespace.enums = cloneTypeCollection(type.enums, { namespace: clonedNamespace });
+                    clonedNamespace.functionDeclarations = cloneTypeCollection(type.functionDeclarations, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.interfaces = cloneTypeCollection(type.interfaces, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.namespaces = cloneTypeCollection(type.namespaces, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.operations = cloneTypeCollection(type.operations, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.scalars = cloneTypeCollection(type.scalars, {
+                        namespace: clonedNamespace,
+                    });
+                    clonedNamespace.unions = cloneTypeCollection(type.unions, { namespace: clonedNamespace });
+                    break;
+                default:
+                    clone = this.program.checker.createType({
+                        ...type,
+                        ...("decorators" in type ? { decorators: [...type.decorators] } : {}),
+                    });
+                    break;
+            }
+            this.realm.get().addType(clone);
+            return clone;
+        },
+    },
+});
+function cloneTypeCollection(collection, options = {}) {
+    const cloneCollection = new Map();
+    for (const [key, type] of collection) {
+        const clone = $.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(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(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;
+        },
+    },
+});
+
+/** @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.
@@ -30864,6 +31611,9 @@ createTypekit();
 function getDoc(program, target) {
     return getDocDataInternal(program, target, "self")?.value;
 }
+// -- @format decorator ---------------------
+const [getFormat, setFormat] = useStateMap("format");
+const [getEncode, setEncodeData] = useStateMap("encode");
 
 const globalLibraryUrlsLoadedSym = Symbol.for("TYPESPEC_LIBRARY_URLS_LOADED");
 if (globalThis[globalLibraryUrlsLoadedSym] === undefined) {