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

package/dist/emitter/index.js

@@ -353,7 +353,7 @@ function getDebugClassNames(lookupItem, parentLookupItem, parentDebugClassNames,
   });
 }
 
-function getAtomicDebugSequenceTree(debugSequenceHash, parentNode) {
+function getDebugTree(debugSequenceHash, parentNode) {
   const lookupItem = DEFINITION_LOOKUP_TABLE[debugSequenceHash];
   if (lookupItem === undefined) {
     return undefined;
@@ -369,7 +369,7 @@ function getAtomicDebugSequenceTree(debugSequenceHash, parentNode) {
   const childrenSequences = debugData.getChildrenSequences(node.sequenceHash);
   childrenSequences.reverse() // first process the overriding children that are merged last
   .forEach(sequence => {
-    const child = getAtomicDebugSequenceTree(sequence, node);
+    const child = getDebugTree(sequence, node);
     if (child) {
       node.children.push(child);
     }
@@ -394,53 +394,6 @@ function getAtomicDebugSequenceTree(debugSequenceHash, parentNode) {
   return node;
 }
 
-function getResetDebugSequence(debugSequenceHash) {
-  const resetClass = DEBUG_RESET_CLASSES[debugSequenceHash];
-  if (resetClass === undefined) {
-    return undefined;
-  }
-  const debugClassNames = [{
-    className: debugSequenceHash
-  }];
-  const node = {
-    sequenceHash: debugSequenceHash,
-    direction: 'ltr',
-    children: [],
-    debugClassNames
-  };
-  node.rules = {};
-  node.slot = 'makeResetStyles()';
-  const [{
-    className
-  }] = node.debugClassNames;
-  const cssRules = debugData.getCSSRules().filter(cssRule => {
-    return cssRule.includes(`.${className}`);
-  });
-  node.rules[className] = cssRules.join('');
-  return node;
-}
-
-function mergeDebugSequence(atomicClases, resetClassName) {
-  const debugResultRootAtomic = atomicClases ? getAtomicDebugSequenceTree(atomicClases) : undefined;
-  const debugResultRootReset = resetClassName ? getResetDebugSequence(resetClassName) : undefined;
-  if (!debugResultRootAtomic && !debugResultRootReset) {
-    return undefined;
-  }
-  if (!debugResultRootAtomic) {
-    return debugResultRootReset;
-  }
-  if (!debugResultRootReset) {
-    return debugResultRootAtomic;
-  }
-  const debugResultRoot = {
-    sequenceHash: debugResultRootAtomic.sequenceHash + debugResultRootReset.sequenceHash,
-    direction: debugResultRootAtomic.direction,
-    children: [debugResultRootAtomic, debugResultRootReset],
-    debugClassNames: [...debugResultRootAtomic.debugClassNames, ...debugResultRootReset.debugClassNames]
-  };
-  return debugResultRoot;
-}
-
 function injectDevTools(document) {
   const window = document.defaultView;
   if (!window || window.__GRIFFEL_DEVTOOLS__) {
@@ -448,18 +401,11 @@ function injectDevTools(document) {
   }
   const devtools = {
     getInfo: element => {
-      let rootDebugSequenceHash;
-      let rootResetDebugClassName;
-      for (const className of element.classList) {
-        if (className.startsWith(SEQUENCE_PREFIX)) {
-          rootDebugSequenceHash = className;
-          return;
-        }
-        if (DEBUG_RESET_CLASSES[className]) {
-          rootResetDebugClassName = className;
-        }
+      const rootDebugSequenceHash = Array.from(element.classList).find(className => className.startsWith(SEQUENCE_PREFIX));
+      if (rootDebugSequenceHash === undefined) {
+        return undefined;
       }
-      return mergeDebugSequence(rootDebugSequenceHash, rootResetDebugClassName);
+      return getDebugTree(rootDebugSequenceHash);
     }
   };
   Object.defineProperty(window, '__GRIFFEL_DEVTOOLS__', {

package/dist/manifest-BNuBm9Cd.js

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

package/dist/react/index.js

@@ -17889,6 +17889,82 @@ function normalizeSlashes(path) {
     return path.replace(backslashRegExp, directorySeparator);
 }
 
+function createSourceFile(text, path) {
+    let lineStarts = undefined;
+    return {
+        text,
+        path,
+        getLineStarts,
+        getLineAndCharacterOfPosition,
+    };
+    function getLineStarts() {
+        return (lineStarts = lineStarts ?? scanLineStarts(text));
+    }
+    function getLineAndCharacterOfPosition(position) {
+        const starts = getLineStarts();
+        let line = binarySearch(starts, position);
+        // When binarySearch returns < 0 indicating that the value was not found, it
+        // returns the bitwise complement of the index where the value would need to
+        // be inserted to keep the array sorted. So flipping the bits back to this
+        // positive index tells us what the line number would be if we were to
+        // create a new line starting at the given position, and subtracting 1 from
+        // that therefore gives us the line number we're after.
+        if (line < 0) {
+            line = ~line - 1;
+        }
+        return {
+            line,
+            character: position - starts[line],
+        };
+    }
+}
+function scanLineStarts(text) {
+    const starts = [];
+    let start = 0;
+    let pos = 0;
+    while (pos < text.length) {
+        const ch = text.charCodeAt(pos);
+        pos++;
+        switch (ch) {
+            case 13 /* CharCode.CarriageReturn */:
+                if (text.charCodeAt(pos) === 10 /* CharCode.LineFeed */) {
+                    pos++;
+                }
+            // fallthrough
+            case 10 /* CharCode.LineFeed */:
+                starts.push(start);
+                start = pos;
+                break;
+        }
+    }
+    starts.push(start);
+    return starts;
+}
+/**
+ * Search sorted array of numbers for the given value. If found, return index
+ * in array where value was found. If not found, return a negative number that
+ * is the bitwise complement of the index where value would need to be inserted
+ * to keep the array sorted.
+ */
+function binarySearch(array, value) {
+    let low = 0;
+    let high = array.length - 1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const v = array[middle];
+        if (v < value) {
+            low = middle + 1;
+        }
+        else if (v > value) {
+            high = middle - 1;
+        }
+        else {
+            return middle;
+        }
+    }
+    return ~low;
+}
+
 var ResolutionResultFlags;
 (function (ResolutionResultFlags) {
     ResolutionResultFlags[ResolutionResultFlags["None"] = 0] = "None";
@@ -18034,7 +18110,7 @@ let manifest;
 try {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    manifest = (await import('../manifest-BVCtXeEX.js')).default;
+    manifest = (await import('../manifest-BNuBm9Cd.js')).default;
 }
 catch {
     const name = "../dist/manifest.js";
@@ -18879,12 +18955,6 @@ const diagnostics = {
             required: "dec first parameter must be required.",
         },
     },
-    "projections-are-experimental": {
-        severity: "warning",
-        messages: {
-            default: "Projections are experimental - your code will need to change as this feature evolves.",
-        },
-    },
     "mixed-string-template": {
         severity: "error",
         messages: {
@@ -28203,6 +28273,67 @@ function findYamlNode(file, path, kind = "value") {
     return current ?? undefined;
 }
 
+function getSourceLocation(target, options = {}) {
+    if (target === NoTarget || target === undefined) {
+        return undefined;
+    }
+    if ("file" in target) {
+        return target;
+    }
+    if (!("kind" in target) && !("entityKind" in target)) {
+        // TemplateInstanceTarget
+        if (!("declarations" in target)) {
+            return getSourceLocationOfNode(target.node, options);
+        }
+        // symbol
+        if (target.flags & 32768 /* SymbolFlags.Using */) {
+            target = target.symbolSource;
+        }
+        if (!target.declarations[0]) {
+            return createSyntheticSourceLocation();
+        }
+        return getSourceLocationOfNode(target.declarations[0], options);
+    }
+    else if ("kind" in target && typeof target.kind === "number") {
+        // node
+        return getSourceLocationOfNode(target, options);
+    }
+    else {
+        // type
+        const targetNode = target.node;
+        if (targetNode) {
+            return getSourceLocationOfNode(targetNode, options);
+        }
+        return createSyntheticSourceLocation();
+    }
+}
+function createSyntheticSourceLocation(loc = "<unknown location>") {
+    return {
+        file: createSourceFile("", loc),
+        pos: 0,
+        end: 0,
+        isSynthetic: true,
+    };
+}
+function getSourceLocationOfNode(node, options) {
+    let root = node;
+    while (root.parent !== undefined) {
+        root = root.parent;
+    }
+    if (root.kind !== SyntaxKind.TypeSpecScript && root.kind !== SyntaxKind.JsSourceFile) {
+        return createSyntheticSourceLocation(node.flags & 8 /* NodeFlags.Synthetic */
+            ? undefined
+            : "<unknown location - cannot obtain source location of unbound node - file bug at https://github.com/microsoft/typespec>");
+    }
+    if (options.locateId && "id" in node && node.id !== undefined) {
+        node = node.id;
+    }
+    return {
+        file: root.file,
+        pos: node.pos,
+        end: node.end,
+    };
+}
 /**
  * Use this to report bugs in the compiler, and not errors in the source code
  * being compiled.
@@ -28218,6 +28349,20 @@ function compilerAssert(condition, message, target) {
     if (condition) {
         return;
     }
+    if (target) {
+        let location;
+        try {
+            location = getSourceLocation(target);
+        }
+        catch (err) { }
+        if (location) {
+            const pos = location.file.getLineAndCharacterOfPosition(location.pos);
+            const file = location.file.path;
+            const line = pos.line + 1;
+            const col = pos.character + 1;
+            message += `\nOccurred while compiling code in ${file} near line ${line}, column ${col}`;
+        }
+    }
     throw new Error(message);
 }
 /**
@@ -28454,24 +28599,36 @@ deepFreeze({
 });
 createJSONSchemaValidator(TypeSpecConfigJsonSchema);
 
-// Contains all intrinsic data setter or getter
-// Anything that the TypeSpec check might should be here.
-function createStateSymbol$1(name) {
+/**
+ * Filters the properties of a model by removing them from the model instance if
+ * a given `filter` predicate is not satisfied.
+ *
+ * @param model - the model to filter properties on
+ * @param filter - the predicate to filter properties with
+ */
+/**
+ * Creates a unique symbol for storing state on objects
+ * @param name The name/description of the state
+ */
+function createStateSymbol(name) {
     return Symbol.for(`TypeSpec.${name}`);
 }
+
+// Contains all intrinsic data setter or getter
+// Anything that the TypeSpec check might should be here.
 const stateKeys = {
-    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"),
+    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"),
 };
 function getDocKey(target) {
     switch (target) {
@@ -29652,6 +29809,35 @@ var ListKind;
     };
 })(ListKind || (ListKind = {}));
 
+const deprecatedKey = createStateSymbol("deprecated");
+/**
+ * Returns complete deprecation details for the given type or node
+ * @param program Program
+ * @param typeOrNode A Type or Node to check for deprecation
+ */
+function getDeprecationDetails(program, typeOrNode) {
+    function isType(maybeType) {
+        return typeof maybeType.kind === "string";
+    }
+    // If we're looking at a type, pull the deprecation details from the state map
+    if (isType(typeOrNode)) {
+        return program.stateMap(deprecatedKey).get(typeOrNode);
+    }
+    else {
+        // Look at the node for a deprecation directive
+        const deprecatedDirective = (typeOrNode.directives ?? []).find((directive) => directive.target.sv === "deprecated");
+        if (deprecatedDirective?.arguments[0].kind === SyntaxKind.StringLiteral) {
+            return {
+                message: deprecatedDirective.arguments[0].value,
+            };
+        }
+    }
+    return undefined;
+}
+
+function isErrorType(type) {
+    return "kind" in type && type.kind === "Intrinsic" && type.name === "ErrorType";
+}
 function isType(entity) {
     return entity.entityKind === "Type";
 }
@@ -30119,6 +30305,7 @@ NumericPrototype.toString = function () {
     ],
 });
 
+/* eslint-disable @typescript-eslint/no-deprecated */
 var Related;
 (function (Related) {
     Related[Related["false"] = 0] = "false";
@@ -30127,6 +30314,274 @@ var Related;
 })(Related || (Related = {}));
 // #endregion
 
+/* eslint-disable @typescript-eslint/no-deprecated */
+/**
+ * Find all named models that could have been the source of the given
+ * property. This includes the named parents of all property sources in a
+ * chain.
+ */
+function getNamedSourceModels(property) {
+    if (!property.sourceProperty) {
+        return undefined;
+    }
+    const set = new Set();
+    for (let p = property; p; p = p.sourceProperty) {
+        if (p.model?.name) {
+            set.add(p.model);
+        }
+    }
+    return set;
+}
+/**
+ * Find derived types of `models` in `possiblyDerivedModels` and add them to
+ * `models`.
+ */
+function addDerivedModels(models, possiblyDerivedModels) {
+    for (const element of possiblyDerivedModels) {
+        if (!models.has(element)) {
+            for (let t = element.baseModel; t; t = t.baseModel) {
+                if (models.has(t)) {
+                    models.add(element);
+                    break;
+                }
+            }
+        }
+    }
+}
+/**
+ * If the input is anonymous (or the provided filter removes properties)
+ * and there exists a named model with the same set of properties
+ * (ignoring filtered properties), then return that named model.
+ * Otherwise, return the input unchanged.
+ *
+ * This can be used by emitters to find a better name for a set of
+ * properties after filtering. For example, given `{ @metadata prop:
+ * string} & SomeName`, and an emitter that wishes to discard properties
+ * marked with `@metadata`, the emitter can use this to recover that the
+ * best name for the remaining properties is `SomeName`.
+ *
+ * @param model The input model
+ * @param filter An optional filter to apply to the input model's
+ * properties.
+ */
+function getEffectiveModelType(program, model, filter) {
+    if (filter) {
+        model = filterModelProperties(program, model, filter);
+    }
+    if (model.name) {
+        // named model
+        return model;
+    }
+    // We would need to change the algorithm if this doesn't hold. We
+    // assume model has no inherited properties below.
+    compilerAssert(!model.baseModel, "Anonymous model with base model.");
+    if (model.properties.size === 0) {
+        // empty model
+        return model;
+    }
+    // Find the candidate set of named model types that could have been the
+    // source of every property in the model.
+    let candidates;
+    for (const property of model.properties.values()) {
+        const sources = getNamedSourceModels(property);
+        if (!sources) {
+            // unsourced property: no possible match
+            return model;
+        }
+        if (!candidates) {
+            // first sourced property: initialize candidates to its sources
+            candidates = sources;
+            continue;
+        }
+        // Add derived sources as we encounter them. If a model is sourced from
+        // a base property, then it can also be sourced from a derived model.
+        //
+        // (Unless it is overridden, but then the presence of the overridden
+        // property will still cause the the base model to be excluded from the
+        // candidates.)
+        //
+        // Note: We depend on the order of that spread and intersect source
+        // properties here, which is that we see properties sourced from derived
+        // types before properties sourced from their base types.
+        addDerivedModels(sources, candidates);
+        // remove candidates that are not common to this property.
+        for (const candidate of candidates) {
+            if (!sources.has(candidate)) {
+                candidates.delete(candidate);
+            }
+        }
+    }
+    // Search for a candidate that has no additional properties (ignoring
+    // filtered properties). If so, it is effectively the same type as the
+    // input model. Consider a candidate that meets this test without
+    // ignoring filtering as a better match than one that requires filtering
+    // to meet this test.
+    let match;
+    for (const candidate of candidates ?? []) {
+        if (model.properties.size === countPropertiesInherited(candidate)) {
+            match = candidate;
+            break; // exact match
+        }
+        if (filter && !match && model.properties.size === countPropertiesInherited(candidate, filter)) {
+            match = candidate;
+            continue; // match with filter: keep searching for exact match
+        }
+    }
+    return match ?? model;
+}
+/**
+ * Applies a filter to the properties of a given type. If no properties
+ * are filtered out, then return the input unchanged. Otherwise, return
+ * a new anonymous model with only the filtered properties.
+ *
+ * @param model The input model to filter.
+ * @param filter The filter to apply. Properties are kept when this returns true.
+ */
+function filterModelProperties(program, model, filter) {
+    let filtered = false;
+    for (const property of walkPropertiesInherited(model)) {
+        if (!filter(property)) {
+            filtered = true;
+            break;
+        }
+    }
+    if (!filtered) {
+        return model;
+    }
+    const properties = createRekeyableMap();
+    const newModel = program.checker.createType({
+        kind: "Model",
+        node: undefined,
+        name: "",
+        indexer: undefined,
+        properties,
+        decorators: [],
+        derivedModels: [],
+        sourceModels: [{ usage: "spread", model }],
+    });
+    for (const property of walkPropertiesInherited(model)) {
+        if (filter(property)) {
+            const newProperty = program.checker.cloneType(property, {
+                sourceProperty: property,
+                model: newModel,
+            });
+            properties.set(property.name, newProperty);
+        }
+    }
+    return finishTypeForProgram(program, newModel);
+}
+/**
+ * Enumerates the properties declared by model or inherited from its base.
+ *
+ * Properties declared by more derived types are enumerated before properties
+ * of less derived types.
+ *
+ * Properties that are overridden are not enumerated.
+ */
+function* walkPropertiesInherited(model) {
+    const returned = new Set();
+    for (let current = model; current; current = current.baseModel) {
+        for (const property of current.properties.values()) {
+            if (returned.has(property.name)) {
+                // skip properties that have been overridden
+                continue;
+            }
+            returned.add(property.name);
+            yield property;
+        }
+    }
+}
+function countPropertiesInherited(model, filter) {
+    let count = 0;
+    for (const property of walkPropertiesInherited(model)) {
+        if (!filter || filter(property)) {
+            count++;
+        }
+    }
+    return count;
+}
+function finishTypeForProgram(program, typeDef) {
+    return finishTypeForProgramAndChecker(program, program.checker.typePrototype, typeDef);
+}
+function finishTypeForProgramAndChecker(program, typePrototype, typeDef) {
+    if ("decorators" in typeDef) {
+        for (const decApp of typeDef.decorators) {
+            applyDecoratorToType(program, decApp, typeDef);
+        }
+    }
+    Object.setPrototypeOf(typeDef, typePrototype);
+    typeDef.isFinished = true;
+    return typeDef;
+}
+function reportDeprecation(program, target, message, reportFunc) {
+    if (program.compilerOptions.ignoreDeprecated !== true) {
+        reportFunc(createDiagnostic({
+            code: "deprecated",
+            format: {
+                message,
+            },
+            target,
+        }));
+    }
+}
+function applyDecoratorToType(program, decApp, target) {
+    compilerAssert("decorators" in target, "Cannot apply decorator to non-decoratable type", target);
+    for (const arg of decApp.args) {
+        if (isType(arg.value) && isErrorType(arg.value)) {
+            // If one of the decorator argument is an error don't run it.
+            return;
+        }
+    }
+    // Is the decorator definition deprecated?
+    if (decApp.definition) {
+        const deprecation = getDeprecationDetails(program, decApp.definition);
+        if (deprecation !== undefined) {
+            reportDeprecation(program, decApp.node ?? target, deprecation.message, program.reportDiagnostic);
+        }
+    }
+    // peel `fn` off to avoid setting `this`.
+    try {
+        const args = decApp.args.map((x) => x.jsValue);
+        const fn = decApp.decorator;
+        const context = createDecoratorContext(program, decApp);
+        fn(context, target, ...args);
+    }
+    catch (error) {
+        // do not fail the language server for exceptions in decorators
+        if (program.compilerOptions.designTimeBuild) {
+            program.reportDiagnostic(createDiagnostic({
+                code: "decorator-fail",
+                format: { decoratorName: decApp.decorator.name, error: error.stack },
+                target: decApp.node ?? target,
+            }));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function createDecoratorContext(program, decApp) {
+    function createPassThruContext(program, decApp) {
+        return {
+            program,
+            decoratorTarget: decApp.node,
+            getArgumentTarget: () => decApp.node,
+            call: (decorator, target, ...args) => {
+                return decorator(createPassThruContext(program, decApp), target, ...args);
+            },
+        };
+    }
+    return {
+        program,
+        decoratorTarget: decApp.node,
+        getArgumentTarget: (index) => {
+            return decApp.args[index]?.node;
+        },
+        call: (decorator, target, ...args) => {
+            return decorator(createPassThruContext(program, decApp), target, ...args);
+        },
+    };
+}
 var ResolutionKind;
 (function (ResolutionKind) {
     ResolutionKind[ResolutionKind["Value"] = 0] = "Value";
@@ -30136,7 +30591,9 @@ var ResolutionKind;
 })(ResolutionKind || (ResolutionKind = {}));
 
 function isIntrinsicType(program, type, kind) {
-    return ignoreDiagnostics(program.checker.isTypeAssignableTo(type.projectionBase ?? type, program.checker.getStdType(kind), type));
+    return ignoreDiagnostics(program.checker.isTypeAssignableTo(
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    type.projectionBase ?? type, program.checker.getStdType(kind), type));
 }
 
 var yu=Object.create;var vt=Object.defineProperty;var Au=Object.getOwnPropertyDescriptor;var vu=Object.getOwnPropertyNames;var Bu=Object.getPrototypeOf,wu=Object.prototype.hasOwnProperty;var fr=e=>{throw TypeError(e)};var dr=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Bt=(e,t)=>{for(var r in t)vt(e,r,{get:t[r],enumerable:true});},_u=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of vu(t))!wu.call(e,u)&&u!==r&&vt(e,u,{get:()=>t[u],enumerable:!(n=Au(t,u))||n.enumerable});return e};var Me=(e,t,r)=>(r=e!=null?yu(Bu(e)):{},_u(vt(r,"default",{value:e,enumerable:true}),e));var xu=(e,t,r)=>t.has(e)||fr("Cannot "+r);var pr=(e,t,r)=>t.has(e)?fr("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(e):t.set(e,r);var pe=(e,t,r)=>(xu(e,t,"access private method"),r);var st=dr((na,Fn)=>{var pn=new Proxy(String,{get:()=>pn});Fn.exports=pn;});var Wn=dr(nr=>{Object.defineProperty(nr,"__esModule",{value:true});function Bi(){return new Proxy({},{get:()=>e=>e})}var Hn=/\r\n|[\n\r\u2028\u2029]/;function wi(e,t,r){let n=Object.assign({column:0,line:-1},e.start),u=Object.assign({},n,e.end),{linesAbove:i=2,linesBelow:o=3}=r||{},s=n.line,a=n.column,D=u.line,l=u.column,p=Math.max(s-(i+1),0),f=Math.min(t.length,D+o);s===-1&&(p=0),D===-1&&(f=t.length);let d=D-s,c={};if(d)for(let F=0;F<=d;F++){let m=F+s;if(!a)c[m]=true;else if(F===0){let h=t[m-1].length;c[m]=[a,h-a+1];}else if(F===d)c[m]=[0,l];else {let h=t[m-F].length;c[m]=[0,h];}}else a===l?a?c[s]=[a,0]:c[s]=true:c[s]=[a,l-a];return {start:p,end:f,markerLines:c}}function _i(e,t,r={}){let u=Bi(),i=e.split(Hn),{start:o,end:s,markerLines:a}=wi(t,i,r),D=t.start&&typeof t.start.column=="number",l=String(s).length,f=e.split(Hn,s).slice(o,s).map((d,c)=>{let F=o+1+c,h=` ${` ${F}`.slice(-l)} |`,C=a[F],v=!a[F+1];if(C){let E="";if(Array.isArray(C)){let g=d.slice(0,Math.max(C[0]-1,0)).replace(/[^\t]/g," "),j=C[1]||1;E=[`
@@ -31561,6 +32018,11 @@ class Realm {
         _a.realmForType.set(clone, this);
         return clone;
     }
+    // TODO better way?
+    /** @internal */
+    get types() {
+        return this.#types;
+    }
     static #knownRealms = new Map();
     static realmForKey(key, parentRealm) {
         return this.#knownRealms.get(key);
@@ -31640,21 +32102,13 @@ defineKit({
     },
 });
 
-/** @experimental */
-function unsafe_useStateMap(key) {
+function useStateMap(key) {
     const getter = (program, target) => program.stateMap(key).get(target);
     const setter = (program, target, value) => program.stateMap(key).set(target, value);
     const mapGetter = (program) => program.stateMap(key);
     return [getter, setter, mapGetter];
 }
 
-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
@@ -31678,11 +32132,11 @@ function useStateMap(key) {
  *
  * This store is used to track the visibility modifiers
  */
-const [getVisibilityStore, setVisibilityStore] = useStateMap("visibilityStore");
+const [getVisibilityStore, setVisibilityStore] = useStateMap(createStateSymbol("visibilityStore"));
 /**
  * Stores the default modifier set for a given visibility class.
  */
-const [getDefaultModifiers, setDefaultModifiers] = useStateMap("defaultVisibilityModifiers");
+const [getDefaultModifiers, setDefaultModifiers] = useStateMap(createStateSymbol("defaultVisibilityModifiers"));
 /**
  * Gets the default modifier set for a visibility class. If no default modifier set has been set, this function will
  * initialize the default modifier set to ALL the visibility class's members.
@@ -31755,8 +32209,8 @@ function getDoc(program, target) {
     return getDocDataInternal(program, target, "self")?.value;
 }
 // -- @format decorator ---------------------
-const [getFormat, setFormat] = useStateMap("format");
-const [getEncode, setEncodeData] = useStateMap("encode");
+const [getFormat, setFormat] = useStateMap(createStateSymbol("format"));
+const [getEncode, setEncodeData] = useStateMap(createStateSymbol("encode"));
 
 defineKit({
     modelProperty: {
@@ -31833,6 +32287,9 @@ defineKit({
         is(type) {
             return type.kind === "Model";
         },
+        getEffectiveModel(model, filter) {
+            return getEffectiveModelType(this.program, model, filter);
+        },
     },
 });
 
@@ -31936,6 +32393,7 @@ defineKit({
                     clone = this.program.checker.createType({
                         ...type,
                         decorators: [...type.decorators],
+                        derivedModels: [...type.derivedModels],
                         properties: copyMap(type.properties),
                         indexer: type.indexer ? { ...type.indexer } : undefined,
                     });
@@ -31960,6 +32418,7 @@ defineKit({
                 case "Enum":
                     clone = this.program.checker.createType({
                         ...type,
+                        decorators: [...type.decorators],
                         members: copyMap(type.members),
                     });
                     break;
@@ -31970,35 +32429,25 @@ defineKit({
                         instantiationParameters: type.instantiationParameters
                             ? [...type.instantiationParameters]
                             : undefined,
+                        // eslint-disable-next-line @typescript-eslint/no-deprecated
                         projections: [...type.projections],
+                        models: copyMap(type.models),
+                        decoratorDeclarations: copyMap(type.decoratorDeclarations),
+                        enums: copyMap(type.enums),
+                        unions: copyMap(type.unions),
+                        operations: copyMap(type.operations),
+                        interfaces: copyMap(type.interfaces),
+                        functionDeclarations: copyMap(type.functionDeclarations),
+                        namespaces: copyMap(type.namespaces),
+                        scalars: copyMap(type.scalars),
                     });
-                    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;
+                case "Scalar":
+                    clone = this.program.checker.createType({
+                        ...type,
+                        decorators: [...type.decorators],
+                        derivedScalars: [...type.derivedScalars],
+                        constructors: copyMap(type.constructors),
                     });
                     break;
                 default:
@@ -32013,17 +32462,6 @@ defineKit({
         },
     },
 });
-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: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/html-program-viewer",
-  "version": "0.65.0-dev.1",
+  "version": "0.65.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.64.0 || >=0.65.0-dev <0.65.0"
+    "@typespec/compiler": "~0.65.0"
   },
   "dependencies": {
     "@fluentui/react-components": "~9.57.0",
@@ -51,12 +51,11 @@
     "@testing-library/dom": "^10.4.0",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.2.0",
-    "@types/node": "~22.10.7",
+    "@types/node": "~22.10.10",
     "@types/react": "~18.3.11",
     "@types/react-dom": "~18.3.0",
-    "@typespec/compiler": "~0.64.0 || >=0.65.0-dev <0.65.0",
     "@vitejs/plugin-react": "~4.3.4",
-    "@vitest/coverage-v8": "^3.0.3",
+    "@vitest/coverage-v8": "^3.0.4",
     "@vitest/ui": "^3.0.3",
     "c8": "^10.1.3",
     "rimraf": "~6.0.1",
@@ -64,7 +63,8 @@
     "vite": "^6.0.11",
     "vite-plugin-checker": "^0.8.0",
     "vite-plugin-dts": "4.5.0",
-    "vitest": "^3.0.3",
+    "vitest": "^3.0.5",
+    "@typespec/compiler": "~0.65.0",
     "@typespec/react-components": "~0.57.0"
   },
   "scripts": {

package/dist/manifest-BVCtXeEX.js

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