@pcbjs/ts-plugin 0.0.0 → 0.0.1-next.9029beb783788cfbb471cc9d57e1b47864c6eaa6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuxuan Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,771 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// scripts/ts-shim.cjs
+var require_ts_shim = __commonJS({
+  "scripts/ts-shim.cjs"(exports2, module2) {
+    "use strict";
+    var ts2;
+    module2.exports = new Proxy({}, { get: (_, k) => k === "__bind" ? (t) => {
+      ts2 = t;
+    } : ts2?.[k] });
+  }
+});
+
+// ../compile/dist/scope.js
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_typescript = __toESM(require_ts_shim(), 1);
+var ScopeError = class extends Error {
+  file;
+  pos;
+  constructor(message, file, pos) {
+    super(message);
+    this.file = file;
+    this.pos = pos;
+    this.name = "ScopeError";
+  }
+};
+var EXTS = [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs"];
+var isFile = (f) => {
+  try {
+    return (0, import_node_fs.statSync)(f).isFile();
+  } catch {
+    return false;
+  }
+};
+var resolveFile = (spec, from) => {
+  if (!spec.startsWith(".") && !spec.startsWith("/"))
+    return null;
+  const base = (0, import_node_path.resolve)((0, import_node_path.dirname)(from), spec);
+  const ext = (0, import_node_path.extname)(base);
+  const stem = [".js", ".jsx", ".mjs"].includes(ext) ? base.slice(0, -ext.length) : null;
+  const tries = [...EXTS.includes(ext) ? [base] : [], ...EXTS.map((x) => base + x), ...stem ? EXTS.map((x) => stem + x) : [], ...EXTS.map((x) => (0, import_node_path.resolve)(base, "index" + x))];
+  const file = tries.find(isFile);
+  return file && (0, import_node_fs.existsSync)(file) ? { file, source: (0, import_node_fs.readFileSync)(file, "utf8") } : null;
+};
+var kindOf = (file) => /\.[jt]sx$/.test(file) ? import_typescript.default.ScriptKind.TSX : /\.[cm]?js$/.test(file) ? import_typescript.default.ScriptKind.JS : import_typescript.default.ScriptKind.TS;
+var parse = (file, source) => import_typescript.default.createSourceFile(file, source, import_typescript.default.ScriptTarget.Latest, true, kindOf(file));
+var has = (n, k) => !!import_typescript.default.canHaveModifiers(n) && !!import_typescript.default.getModifiers(n)?.some((m) => m.kind === k);
+function bindingNames(name, out2 = []) {
+  if (import_typescript.default.isIdentifier(name))
+    out2.push(name.text);
+  else
+    for (const e of name.elements)
+      if (!import_typescript.default.isOmittedExpression(e))
+        bindingNames(e.name, out2);
+  return out2;
+}
+function moduleExports(mod, resolveModule = resolveFile, seen = /* @__PURE__ */ new Set()) {
+  const out2 = /* @__PURE__ */ new Set();
+  if (seen.has(mod.file))
+    return out2;
+  seen.add(mod.file);
+  const sf = parse(mod.file, mod.source);
+  const types = /* @__PURE__ */ new Set(), values = /* @__PURE__ */ new Set();
+  for (const st of sf.statements) {
+    if (import_typescript.default.isInterfaceDeclaration(st) || import_typescript.default.isTypeAliasDeclaration(st))
+      types.add(st.name.text);
+    else if (import_typescript.default.isVariableStatement(st))
+      for (const d of st.declarationList.declarations)
+        bindingNames(d.name).forEach((n) => values.add(n));
+    else if ((import_typescript.default.isFunctionDeclaration(st) || import_typescript.default.isClassDeclaration(st) || import_typescript.default.isEnumDeclaration(st) || import_typescript.default.isModuleDeclaration(st)) && st.name && import_typescript.default.isIdentifier(st.name))
+      values.add(st.name.text);
+    else if (import_typescript.default.isImportDeclaration(st) && st.importClause && !st.importClause.isTypeOnly) {
+      const c = st.importClause;
+      if (c.name)
+        values.add(c.name.text);
+      if (c.namedBindings && import_typescript.default.isNamespaceImport(c.namedBindings))
+        values.add(c.namedBindings.name.text);
+      else if (c.namedBindings) {
+        for (const e of c.namedBindings.elements)
+          if (!e.isTypeOnly)
+            values.add(e.name.text);
+      }
+    }
+  }
+  for (const st of sf.statements) {
+    if (import_typescript.default.isExportDeclaration(st)) {
+      if (st.isTypeOnly)
+        continue;
+      const spec = st.moduleSpecifier && import_typescript.default.isStringLiteral(st.moduleSpecifier) ? st.moduleSpecifier.text : void 0;
+      if (!st.exportClause) {
+        const m = spec !== void 0 ? resolveModule(spec, mod.file) : null;
+        if (m)
+          for (const n of moduleExports(m, resolveModule, seen))
+            out2.add(n);
+      } else if (import_typescript.default.isNamespaceExport(st.exportClause))
+        out2.add(st.exportClause.name.text);
+      else
+        for (const e of st.exportClause.elements) {
+          const local = (e.propertyName ?? e.name).text;
+          if (!e.isTypeOnly && (spec !== void 0 || !types.has(local) || values.has(local)))
+            out2.add(e.name.text);
+        }
+      continue;
+    }
+    if (!has(st, import_typescript.default.SyntaxKind.ExportKeyword) || has(st, import_typescript.default.SyntaxKind.DefaultKeyword))
+      continue;
+    if (import_typescript.default.isVariableStatement(st))
+      for (const d of st.declarationList.declarations)
+        bindingNames(d.name).forEach((n) => out2.add(n));
+    else if ((import_typescript.default.isFunctionDeclaration(st) || import_typescript.default.isClassDeclaration(st) || import_typescript.default.isEnumDeclaration(st) || import_typescript.default.isModuleDeclaration(st) || import_typescript.default.isImportEqualsDeclaration(st)) && st.name && import_typescript.default.isIdentifier(st.name))
+      out2.add(st.name.text);
+  }
+  out2.delete("default");
+  return out2;
+}
+var GLOBALS = /* @__PURE__ */ new Set([...Object.getOwnPropertyNames(globalThis), "globalThis", "undefined", "arguments", "require", "module", "exports", "__dirname", "__filename", "window", "document", "self", "navigator", "location"]);
+var Scope = class {
+  parent;
+  names = /* @__PURE__ */ new Set();
+  fn;
+  constructor(parent, fn = false) {
+    this.parent = parent;
+    this.fn = fn || !parent ? this : parent.fn;
+  }
+  has(n) {
+    return this.names.has(n) || !!this.parent?.has(n);
+  }
+};
+function freeNames(sf) {
+  const refs = [];
+  const root = new Scope(null);
+  const declare = (name, s) => bindingNames(name).forEach((n) => s.names.add(n));
+  const binding = (name, s) => {
+    if (import_typescript.default.isIdentifier(name))
+      return;
+    for (const e of name.elements) {
+      if (import_typescript.default.isOmittedExpression(e))
+        continue;
+      if (e.propertyName && import_typescript.default.isComputedPropertyName(e.propertyName))
+        visit(e.propertyName.expression, s);
+      if (e.initializer)
+        visit(e.initializer, s);
+      binding(e.name, s);
+    }
+  };
+  const typeRefs = (n, s) => {
+    if (import_typescript.default.isTypeQueryNode(n)) {
+      let e = n.exprName;
+      while (import_typescript.default.isQualifiedName(e))
+        e = e.left;
+      refs.push([e.text, s]);
+      return;
+    }
+    import_typescript.default.forEachChild(n, (c) => typeRefs(c, s));
+  };
+  const fnLike = (n, s) => {
+    const f = new Scope(s, true);
+    if (import_typescript.default.isFunctionExpression(n) && n.name)
+      f.names.add(n.name.text);
+    if (!import_typescript.default.isArrowFunction(n))
+      f.names.add("arguments");
+    if (n.name && import_typescript.default.isComputedPropertyName(n.name))
+      visit(n.name.expression, s);
+    for (const p of n.parameters) {
+      declare(p.name, f);
+      binding(p.name, f);
+      if (p.type)
+        typeRefs(p.type, f);
+      if (p.initializer)
+        visit(p.initializer, f);
+      p.modifiers?.forEach((m) => visit(m, f));
+    }
+    if (n.type)
+      typeRefs(n.type, f);
+    const body = n.body;
+    if (body && import_typescript.default.isBlock(body))
+      body.statements.forEach((st) => visit(st, f));
+    else if (body)
+      visit(body, f);
+  };
+  const klass = (n, s) => {
+    const c = new Scope(s);
+    if (n.name)
+      c.names.add(n.name.text);
+    n.modifiers?.forEach((m) => visit(m, s));
+    for (const h of n.heritageClauses ?? [])
+      if (h.token === import_typescript.default.SyntaxKind.ExtendsKeyword)
+        h.types.forEach((t) => visit(t.expression, s));
+    for (const m of n.members) {
+      if (m.name && import_typescript.default.isComputedPropertyName(m.name))
+        visit(m.name.expression, c);
+      if (import_typescript.default.isPropertyDeclaration(m) && m.initializer)
+        visit(m.initializer, c);
+      else if (import_typescript.default.isFunctionLike(m))
+        fnLike(m, c);
+      else if (import_typescript.default.isClassStaticBlockDeclaration(m))
+        visit(m.body, c);
+    }
+  };
+  const visit = (n, s) => {
+    if (import_typescript.default.isIdentifier(n)) {
+      refs.push([n.text, s]);
+      return;
+    }
+    if (import_typescript.default.isExpressionWithTypeArguments(n))
+      return visit(n.expression, s);
+    if (import_typescript.default.isTypeNode(n))
+      return typeRefs(n, s);
+    switch (n.kind) {
+      case import_typescript.default.SyntaxKind.ImportDeclaration: {
+        const c = n.importClause;
+        if (c?.name)
+          root.names.add(c.name.text);
+        if (c?.namedBindings)
+          import_typescript.default.isNamespaceImport(c.namedBindings) ? root.names.add(c.namedBindings.name.text) : c.namedBindings.elements.forEach((e) => root.names.add(e.name.text));
+        return;
+      }
+      case import_typescript.default.SyntaxKind.ImportEqualsDeclaration:
+        s.names.add(n.name.text);
+        return;
+      case import_typescript.default.SyntaxKind.ExportDeclaration: {
+        const e = n;
+        if (!e.moduleSpecifier && !e.isTypeOnly && e.exportClause && import_typescript.default.isNamedExports(e.exportClause)) {
+          for (const x of e.exportClause.elements)
+            if (!x.isTypeOnly)
+              refs.push([(x.propertyName ?? x.name).text, s]);
+        }
+        return;
+      }
+      case import_typescript.default.SyntaxKind.InterfaceDeclaration:
+      case import_typescript.default.SyntaxKind.TypeAliasDeclaration:
+        return typeRefs(n, s);
+      case import_typescript.default.SyntaxKind.TypeParameter:
+      case import_typescript.default.SyntaxKind.BreakStatement:
+      case import_typescript.default.SyntaxKind.ContinueStatement:
+      case import_typescript.default.SyntaxKind.MetaProperty:
+      case import_typescript.default.SyntaxKind.JsxClosingElement:
+      case import_typescript.default.SyntaxKind.JsxNamespacedName:
+        return;
+      case import_typescript.default.SyntaxKind.EnumDeclaration:
+        s.names.add(n.name.text);
+        return;
+      case import_typescript.default.SyntaxKind.ModuleDeclaration: {
+        const m = n;
+        if (import_typescript.default.isIdentifier(m.name))
+          s.names.add(m.name.text);
+        return;
+      }
+      case import_typescript.default.SyntaxKind.VariableDeclarationList: {
+        const l = n;
+        const target = l.flags & (import_typescript.default.NodeFlags.Let | import_typescript.default.NodeFlags.Const | import_typescript.default.NodeFlags.Using) ? s : s.fn;
+        for (const d of l.declarations) {
+          declare(d.name, target);
+          binding(d.name, s);
+          if (d.type)
+            typeRefs(d.type, s);
+          if (d.initializer)
+            visit(d.initializer, s);
+        }
+        return;
+      }
+      case import_typescript.default.SyntaxKind.FunctionDeclaration: {
+        const f = n;
+        if (f.name)
+          s.names.add(f.name.text);
+        return fnLike(f, s);
+      }
+      case import_typescript.default.SyntaxKind.ClassDeclaration: {
+        const c = n;
+        if (c.name)
+          s.names.add(c.name.text);
+        return klass(c, s);
+      }
+      case import_typescript.default.SyntaxKind.ClassExpression:
+        return klass(n, s);
+      case import_typescript.default.SyntaxKind.FunctionExpression:
+      case import_typescript.default.SyntaxKind.ArrowFunction:
+      case import_typescript.default.SyntaxKind.MethodDeclaration:
+      case import_typescript.default.SyntaxKind.GetAccessor:
+      case import_typescript.default.SyntaxKind.SetAccessor:
+      case import_typescript.default.SyntaxKind.Constructor:
+        return fnLike(n, s);
+      case import_typescript.default.SyntaxKind.Block:
+      case import_typescript.default.SyntaxKind.CaseBlock:
+      case import_typescript.default.SyntaxKind.ForStatement:
+      case import_typescript.default.SyntaxKind.ForInStatement:
+      case import_typescript.default.SyntaxKind.ForOfStatement: {
+        const b = new Scope(s);
+        import_typescript.default.forEachChild(n, (c) => visit(c, b));
+        return;
+      }
+      case import_typescript.default.SyntaxKind.CatchClause: {
+        const c = n, b = new Scope(s);
+        if (c.variableDeclaration) {
+          declare(c.variableDeclaration.name, b);
+          binding(c.variableDeclaration.name, b);
+        }
+        c.block.statements.forEach((st) => visit(st, b));
+        return;
+      }
+      case import_typescript.default.SyntaxKind.PropertyAccessExpression:
+        return visit(n.expression, s);
+      case import_typescript.default.SyntaxKind.PropertyAssignment: {
+        const p = n;
+        if (import_typescript.default.isComputedPropertyName(p.name))
+          visit(p.name.expression, s);
+        return visit(p.initializer, s);
+      }
+      case import_typescript.default.SyntaxKind.ShorthandPropertyAssignment: {
+        const p = n;
+        refs.push([p.name.text, s]);
+        if (p.objectAssignmentInitializer)
+          visit(p.objectAssignmentInitializer, s);
+        return;
+      }
+      case import_typescript.default.SyntaxKind.LabeledStatement:
+        return visit(n.statement, s);
+      case import_typescript.default.SyntaxKind.JsxAttribute: {
+        const a = n;
+        if (a.initializer)
+          visit(a.initializer, s);
+        return;
+      }
+      case import_typescript.default.SyntaxKind.JsxOpeningElement:
+      case import_typescript.default.SyntaxKind.JsxSelfClosingElement: {
+        const e = n;
+        if (!import_typescript.default.isIdentifier(e.tagName) || !/^[a-z]/.test(e.tagName.text))
+          visit(e.tagName, s);
+        return visit(e.attributes, s);
+      }
+    }
+    import_typescript.default.forEachChild(n, (c) => visit(c, s));
+  };
+  sf.statements.forEach((st) => visit(st, root));
+  const out2 = [];
+  for (const [n, s] of refs)
+    if (!s.has(n) && !GLOBALS.has(n) && !out2.includes(n))
+      out2.push(n);
+  return out2;
+}
+function schematicImports(sf) {
+  const ns = /* @__PURE__ */ new Map();
+  for (const st of sf.statements) {
+    const b = import_typescript.default.isImportDeclaration(st) && !st.importClause?.isTypeOnly ? st.importClause?.namedBindings : void 0;
+    if (b && import_typescript.default.isNamespaceImport(b))
+      ns.set(b.name.text, st);
+  }
+  const out2 = [];
+  if (!ns.size)
+    return out2;
+  const visit = (n) => {
+    if (import_typescript.default.isJsxAttribute(n) && import_typescript.default.isIdentifier(n.name) && n.name.text === "schematic" && n.initializer && import_typescript.default.isJsxExpression(n.initializer)) {
+      const e = n.initializer.expression;
+      const d = e && import_typescript.default.isIdentifier(e) ? ns.get(e.text) : void 0;
+      if (d && !out2.some((o) => o.ns === e.text))
+        out2.push({ ns: e.text, decl: d, attr: n });
+    }
+    import_typescript.default.forEachChild(n, visit);
+  };
+  visit(sf);
+  return out2;
+}
+function scopeInject(source, resolveModule = resolveFile, file = "design.tsx") {
+  if (!source.includes("schematic"))
+    return null;
+  const sf = parse(file, source);
+  const found = schematicImports(sf);
+  if (!found.length)
+    return null;
+  if (found.length > 1) {
+    const at2 = found[1].attr.getStart(sf), { line } = sf.getLineAndCharacterOfPosition(at2);
+    throw new ScopeError(`${file}:${line + 1}: <PCB schematic> takes the namespaces ${found.map((f) => f.ns).join(" and ")} in one file; put each board with its own schematic module in a file of its own`, file, at2);
+  }
+  const { ns, decl } = found[0];
+  const mod = resolveModule(decl.moduleSpecifier.text, file);
+  if (!mod)
+    return null;
+  const exported = moduleExports(mod, resolveModule);
+  const names = freeNames(sf).filter((n) => exported.has(n)).sort();
+  if (!names.length)
+    return null;
+  const at = decl.getEnd(), text = `;const {${names.join(",")}}=${ns};`;
+  return { code: source.slice(0, at) + text + source.slice(at), at, text, ns, module: mod.file, names };
+}
+var toSource = (inj, pos) => !inj || pos <= inj.at ? pos : pos < inj.at + inj.text.length ? inj.at : pos - inj.text.length;
+var toInjected = (inj, pos) => !inj || pos < inj.at ? pos : pos + inj.text.length;
+
+// src/map.ts
+var DROP = /* @__PURE__ */ Symbol("drop");
+function inside(inj, start, length) {
+  if (!inj) return false;
+  const end = inj.at + inj.text.length;
+  return length ? start >= inj.at && start + length <= end : start > inj.at && start < end;
+}
+var into = (inj, pos) => toInjected(inj, pos);
+var intoEnd = (inj, pos) => inj && pos <= inj.at ? pos : toInjected(inj, pos);
+var out = (inj, pos) => toSource(inj, pos);
+function outSpan(inj, s) {
+  if (!inj) return s;
+  if (inside(inj, s.start, s.length)) return null;
+  const start = out(inj, s.start);
+  return { start, length: out(inj, s.start + s.length) - start };
+}
+var intoSpan = (inj, s) => {
+  const start = into(inj, s.start);
+  return { start, length: intoEnd(inj, s.start + s.length) - start };
+};
+var isSpan = (v) => typeof v.start === "number" && typeof v.length === "number" && Object.keys(v).length === 2;
+var OWN = /* @__PURE__ */ new Set(["textSpan", "span", "triggerSpan", "nameSpan", "selectionSpan"]);
+function outResult(v, file, injOf) {
+  if (Array.isArray(v)) return v.map((x) => outResult(x, file, injOf)).filter((x) => x !== DROP);
+  if (!v || typeof v !== "object") return v;
+  const proto = Object.getPrototypeOf(v);
+  if (proto !== Object.prototype && proto !== null) return v;
+  if (typeof v.fileName === "string") file = v.fileName;
+  const inj = file ? injOf(file) : null;
+  if (isSpan(v)) return outSpan(inj, v) ?? DROP;
+  const o = { ...v };
+  for (const k of Object.keys(o)) {
+    const x = o[k];
+    if (typeof x === "number" && (k === "position" || k === "renameLocation")) {
+      const at = k === "renameLocation" && typeof o.renameFilename === "string" ? injOf(o.renameFilename) : inj;
+      if (k === "position" && inside(at, x, 0)) return DROP;
+      o[k] = out(at, x);
+    } else if (x && typeof x === "object") {
+      const m = outResult(x, file, injOf);
+      if (m !== DROP) o[k] = m;
+      else if (OWN.has(k)) return DROP;
+      else delete o[k];
+    }
+  }
+  return o;
+}
+function lineStarts(text) {
+  const out2 = [0];
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 13 && text.charCodeAt(i + 1) === 10) i++;
+    if (c === 10 || c === 13 || c === 8232 || c === 8233) out2.push(i + 1);
+  }
+  return out2;
+}
+
+// src/index.ts
+var CONFIGS = ["pcb.config", "pcbjs.config"].flatMap((n) => ["ts", "mts", "js", "mjs"].map((x) => `${n}.${x}`));
+var WRAPPED = /* @__PURE__ */ Symbol.for("pcbjs.ts-plugin");
+var CANNOT_FIND = /* @__PURE__ */ new Set([2304, 2552]);
+var SCOPE_ERROR = 99001;
+var AT_POS = [
+  "getCompletionEntrySymbol",
+  "getQuickInfoAtPosition",
+  "getTypeDefinitionAtPosition",
+  "getImplementationAtPosition",
+  "getDocumentHighlights",
+  "getRenameInfo",
+  "getSignatureHelpItems",
+  "getSmartSelectionRange",
+  "getBraceMatchingAtPosition",
+  "getIndentationAtPosition",
+  "getFormattingEditsAfterKeystroke",
+  "isValidBraceCompletionAtPosition",
+  "getJsxClosingTagAtPosition",
+  "getLinkedEditingRangeAtPosition",
+  "getSpanOfEnclosingComment",
+  "getDocCommentTemplateAtPosition",
+  "prepareCallHierarchy",
+  "provideCallHierarchyIncomingCalls",
+  "provideCallHierarchyOutgoingCalls",
+  "getBreakpointStatementAtPosition"
+];
+var AT_RANGE = ["getNameOrDottedNameSpan", "getCodeFixesAtPosition", "getFormattingEditsForRange"];
+var AT_SPAN = ["provideInlayHints", "getSemanticClassifications", "getSyntacticClassifications"];
+var AT_TEXT_RANGE = ["toggleLineComment", "toggleMultilineComment", "commentSelection", "uncommentSelection"];
+var ENCODED = ["getEncodedSemanticClassifications", "getEncodedSyntacticClassifications"];
+var RESULT_ONLY = [
+  "getOutliningSpans",
+  "getNavigationBarItems",
+  "getNavigationTree",
+  "getFormattingEditsForDocument",
+  "organizeImports",
+  "getEditsForFileRename",
+  "getCombinedCodeFix",
+  "getNavigateToItems",
+  "getFileReferences",
+  "getTodoComments"
+];
+var DIAGNOSTICS = ["getSyntacticDiagnostics", "getSemanticDiagnostics", "getSuggestionDiagnostics"];
+function init({ typescript: ts2 }) {
+  ;
+  require_ts_shim().__bind?.(ts2);
+  function create(info) {
+    const host = info.languageServiceHost;
+    const ls = info.languageService;
+    if (host[WRAPPED]) return ls;
+    host[WRAPPED] = true;
+    const log = (m) => info.project?.projectService?.logger?.info(`[pcbjs] ${m}`);
+    const snap0 = host.getScriptSnapshot.bind(host);
+    const ver0 = host.getScriptVersion.bind(host);
+    const exists = (f) => host.fileExists?.(f) ?? ts2.sys.fileExists(f);
+    const read = (f) => {
+      const s = snap0(f);
+      return s ? s.getText(0, s.getLength()) : host.readFile?.(f) ?? ts2.sys.readFile(f);
+    };
+    const modHost = {
+      fileExists: exists,
+      readFile: (f) => host.readFile?.(f) ?? ts2.sys.readFile(f),
+      directoryExists: (d) => host.directoryExists?.(d) ?? ts2.sys.directoryExists(d),
+      realpath: host.realpath?.bind(host) ?? ts2.sys.realpath,
+      getCurrentDirectory: () => host.getCurrentDirectory(),
+      getDirectories: (d) => host.getDirectories?.(d) ?? ts2.sys.getDirectories(d)
+    };
+    const projects = /* @__PURE__ */ new Map();
+    const inProject = (dir) => {
+      let hit = projects.get(dir);
+      if (hit !== void 0) return hit;
+      const up = dir.replace(/\/[^/]*$/, "");
+      hit = !/\/node_modules(\/|$)/.test(dir) && (CONFIGS.some((c) => exists(`${dir}/${c}`)) || up !== dir && up !== "" && inProject(up));
+      projects.set(dir, hit);
+      return hit;
+    };
+    const wanted = (f) => f.endsWith(".tsx") && inProject(f.replace(/\/[^/]*$/, ""));
+    const resolver = (deps, seen) => (s, from) => {
+      seen?.(s, from);
+      const r = ts2.resolveModuleName(s, from, host.getCompilationSettings(), modHost, host.getModuleResolutionCache?.()).resolvedModule;
+      if (!r || r.isExternalLibraryImport) return null;
+      const text = read(r.resolvedFileName);
+      if (text === void 0) return null;
+      deps.push(r.resolvedFileName);
+      return { file: r.resolvedFileName, source: text };
+    };
+    const cache = /* @__PURE__ */ new Map();
+    const fresh = (e, version) => e && e.version === version && e.deps.every(([d, v]) => ver0(d) === v);
+    function entry(file) {
+      if (!wanted(file)) return void 0;
+      const version = ver0(file);
+      const old = cache.get(file);
+      if (fresh(old, version)) return old;
+      const source = read(file);
+      if (source === void 0) return void 0;
+      const deps = [];
+      let spec;
+      const resolveModule = resolver(deps, (s, from) => {
+        if (from === file) spec ??= s;
+      });
+      const e = { key: "", version, deps: [], inj: null, source };
+      try {
+        e.inj = scopeInject(source, resolveModule, file);
+      } catch (err) {
+        if (err instanceof ScopeError) e.error = err;
+        else log(`scope of ${file}: ${err.message}`);
+      }
+      e.spec = spec;
+      e.deps = deps.map((d) => [d, ver0(d)]);
+      e.key = e.deps.length ? `${version}|${e.deps.map((d) => d[1]).join("|")}` : version;
+      if (e.inj) e.snap = ts2.ScriptSnapshot.fromString(e.inj.code);
+      cache.set(file, e);
+      return e;
+    }
+    const injOf = (f) => entry(f)?.inj;
+    host.getScriptVersion = (f) => entry(f)?.key ?? ver0(f);
+    host.getScriptSnapshot = (f) => entry(f)?.snap ?? snap0(f);
+    const result = (v, file) => {
+      if (![...cache.values()].some((e) => e.inj)) return v;
+      const m = outResult(v, file, injOf);
+      return m === DROP ? void 0 : m;
+    };
+    const insideOf = (d) => inside(injOf(d.fileName), d.textSpan.start, d.textSpan.length);
+    const viaExport = (defs) => defs?.flatMap((d) => insideOf(d) ? (ls.getDefinitionAtPosition(d.fileName, d.textSpan.start) ?? []).filter((x) => !insideOf(x)) : [d]);
+    function scopedUses(first, at) {
+      const hit = first.find(insideOf);
+      if (!hit) return void 0;
+      const all = [...first];
+      for (const d of viaExport(ls.getDefinitionAtPosition(hit.fileName, hit.textSpan.start)) ?? []) {
+        for (const l of at(d.fileName, d.textSpan.start) ?? []) {
+          all.push(l);
+          if (insideOf(l) && l !== hit) all.push(...at(l.fileName, l.textSpan.start) ?? []);
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      return all.filter((l) => !insideOf(l) && !seen.has(`${l.fileName}:${l.textSpan.start}`) && !!seen.add(`${l.fileName}:${l.textSpan.start}`));
+    }
+    function useSite(file, e, name) {
+      const sf = ls.getProgram()?.getSourceFile(file);
+      const inj = e.inj;
+      if (!sf || !inj) return void 0;
+      let found;
+      const visit = (n) => {
+        if (found !== void 0) return;
+        if (ts2.isIdentifier(n) && n.text === name && !inside(inj, n.getStart(sf), name.length)) {
+          const p2 = n.parent;
+          const member = ts2.isPropertyAccessExpression(p2) && p2.name === n || ts2.isPropertyAssignment(p2) && p2.name === n || ts2.isJsxAttribute(p2) && p2.name === n;
+          if (!member) found = out(inj, n.getStart(sf));
+        }
+        ts2.forEachChild(n, visit);
+      };
+      visit(sf);
+      return found;
+    }
+    const specAt = (e) => {
+      const i = e.spec === void 0 ? -1 : e.source.lastIndexOf(e.spec, e.inj?.at ?? e.source.length);
+      return i < 0 ? { start: 0, length: 0 } : { start: i, length: e.spec.length };
+    };
+    function view(sf, e) {
+      return e.view ??= Object.create(sf, { text: { value: e.source }, lineMap: { value: lineStarts(e.source) } });
+    }
+    function outDiag(d) {
+      const e = d.file && entry(d.file.fileName);
+      if (!e || d.start === void 0 || !e.inj && e.spec === void 0) return d;
+      const inj = e.inj;
+      const len = d.length ?? 0;
+      let messageText = d.messageText;
+      let span;
+      if (inside(inj, d.start, len)) {
+        const name = /^[A-Za-z_$][\w$]*/.exec(inj.code.slice(d.start))?.[0];
+        const use = name === void 0 ? void 0 : useSite(d.file.fileName, e, name);
+        span = use === void 0 ? specAt(e) : { start: use, length: name.length };
+        if (name) messageText = `${name} is not exported by ${e.spec}`;
+      } else {
+        span = outSpan(inj, { start: d.start, length: len });
+        if (e.spec !== void 0 && CANNOT_FIND.has(d.code)) {
+          const name = e.source.slice(span.start, span.start + span.length);
+          const flat = ts2.flattenDiagnosticMessageText(d.messageText, "\n");
+          const hint = /Did you mean .*$/.exec(flat)?.[0];
+          messageText = `${name} is not exported by ${e.spec}${hint ? `. ${hint}` : ""}`;
+        }
+      }
+      const related = "relatedInformation" in d && d.relatedInformation ? { relatedInformation: d.relatedInformation.map(outDiag).filter((r) => !!r) } : {};
+      return { ...d, ...related, file: e.inj ? view(d.file, e) : d.file, start: span.start, length: span.length, messageText };
+    }
+    const scopeError = (file) => {
+      const e = entry(file);
+      if (!e?.error) return [];
+      const sf = ls.getProgram()?.getSourceFile(file);
+      return [{ category: ts2.DiagnosticCategory.Error, code: SCOPE_ERROR, source: "pcbjs", file: sf && view(sf, e), start: e.error.pos, length: 1, messageText: e.error.message }];
+    };
+    const p = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(ls)) {
+      const f = ls[k];
+      p[k] = typeof f === "function" ? f.bind(ls) : f;
+    }
+    const fn = ls;
+    for (const k of AT_POS) p[k] = (file, pos, ...rest) => result(fn[k](file, into(injOf(file), pos), ...rest), file);
+    for (const k of AT_RANGE) p[k] = (file, start, end, ...rest) => {
+      const inj = injOf(file);
+      return result(fn[k](file, into(inj, start), intoEnd(inj, end), ...rest), file);
+    };
+    for (const k of AT_SPAN) p[k] = (file, span, ...rest) => result(fn[k](file, intoSpan(injOf(file), span), ...rest), file);
+    for (const k of AT_TEXT_RANGE) p[k] = (file, r, ...rest) => {
+      const inj = injOf(file);
+      return result(fn[k](file, { pos: into(inj, r.pos), end: intoEnd(inj, r.end) }, ...rest), file);
+    };
+    for (const k of RESULT_ONLY) p[k] = (...a) => result(fn[k](...a), typeof a[0] === "string" ? a[0] : void 0);
+    for (const k of ENCODED) p[k] = (file, span, ...rest) => {
+      const inj = injOf(file);
+      const c = fn[k](file, intoSpan(inj, span), ...rest);
+      if (!inj) return c;
+      const spans = [];
+      for (let i = 0; i < c.spans.length; i += 3) {
+        const s = outSpan(inj, { start: c.spans[i], length: c.spans[i + 1] });
+        if (s) spans.push(s.start, s.length, c.spans[i + 2]);
+      }
+      return { ...c, spans };
+    };
+    for (const k of DIAGNOSTICS) p[k] = (file) => {
+      const ds = fn[k](file).map(outDiag).filter((d) => !!d);
+      return k === "getSemanticDiagnostics" ? [...scopeError(file), ...ds] : ds;
+    };
+    const posOrRange = (inj, r) => typeof r === "number" ? into(inj, r) : { pos: into(inj, r.pos), end: intoEnd(inj, r.end) };
+    p.getApplicableRefactors = (file, r, ...rest) => result(fn.getApplicableRefactors(file, posOrRange(injOf(file), r), ...rest), file);
+    p.getMoveToRefactoringFileSuggestions = (file, r, ...rest) => result(fn.getMoveToRefactoringFileSuggestions(file, posOrRange(injOf(file), r), ...rest), file);
+    p.getEditsForRefactor = (file, fmt, r, ...rest) => result(fn.getEditsForRefactor(file, fmt, posOrRange(injOf(file), r), ...rest), file);
+    const exportsOf = (file, e) => {
+      if (e.exports) return e.exports;
+      const res = resolver([]);
+      const mod = e.spec === void 0 ? null : res(e.spec, file);
+      return e.exports = mod ? [...moduleExports(mod, res)].sort() : [];
+    };
+    function exportName(file, name) {
+      const program = ls.getProgram();
+      const sf = program?.getSourceFile(file);
+      if (!program || !sf) return void 0;
+      const checker = program.getTypeChecker();
+      for (const st of sf.statements) {
+        if (!ts2.isImportDeclaration(st) || !st.importClause?.namedBindings || !ts2.isNamespaceImport(st.importClause.namedBindings)) continue;
+        const mod = checker.getSymbolAtLocation(st.moduleSpecifier);
+        let sym = mod && checker.getExportsOfModule(mod).find((x) => x.name === name);
+        if (sym && sym.flags & ts2.SymbolFlags.Alias) sym = checker.getAliasedSymbol(sym);
+        const decl = sym?.declarations?.[0];
+        const id = decl && ts2.getNameOfDeclaration(decl);
+        if (id && decl) return { fileName: decl.getSourceFile().fileName, pos: id.getStart() };
+      }
+      return void 0;
+    }
+    p.getCompletionsAtPosition = (file, pos, ...rest) => {
+      const r = result(fn.getCompletionsAtPosition(file, into(injOf(file), pos), ...rest), file);
+      const e = entry(file);
+      if (!r || !e?.spec || !r.isGlobalCompletion) return r;
+      const have = new Set(r.entries.map((x) => x.name));
+      const more = exportsOf(file, e).filter((n) => !have.has(n)).map((name) => ({ name, kind: ts2.ScriptElementKind.constElement, kindModifiers: "", sortText: "11" }));
+      return { ...r, entries: [...r.entries, ...more] };
+    };
+    p.getCompletionEntryDetails = (file, pos, name, ...rest) => {
+      const d = fn.getCompletionEntryDetails(file, into(injOf(file), pos), name, ...rest);
+      if (d) return result(d, file);
+      const e = entry(file);
+      const at = e?.spec !== void 0 && exportsOf(file, e).includes(name) ? exportName(file, name) : void 0;
+      const qi = at && ls.getQuickInfoAtPosition(at.fileName, at.pos);
+      return qi && { name, kind: qi.kind, kindModifiers: qi.kindModifiers, displayParts: qi.displayParts ?? [], documentation: qi.documentation, tags: qi.tags };
+    };
+    p.getDefinitionAtPosition = (file, pos) => result(viaExport(ls.getDefinitionAtPosition(file, into(injOf(file), pos))), file);
+    p.getDefinitionAndBoundSpan = (file, pos) => {
+      const r = ls.getDefinitionAndBoundSpan(file, into(injOf(file), pos));
+      return r && result({ ...r, definitions: viaExport(r.definitions) }, file);
+    };
+    p.getReferencesAtPosition = (file, pos) => {
+      const at = (f, q) => ls.getReferencesAtPosition(f, q);
+      const first = at(file, into(injOf(file), pos));
+      return result(first && (scopedUses(first, at) ?? first), file);
+    };
+    p.findReferences = (file, pos) => {
+      const syms = ls.findReferences(file, into(injOf(file), pos));
+      const refs = syms?.flatMap((s) => s.references);
+      const uses = refs && scopedUses(refs, (f, q) => ls.getReferencesAtPosition(f, q));
+      if (!syms || !uses) return result(syms, file);
+      const def = viaExport(syms.map((s) => s.definition).filter((d) => insideOf(d)))?.[0];
+      const owner = def && ls.findReferences(def.fileName, def.textSpan.start)?.[0]?.definition;
+      return result([{ definition: owner ?? syms[0].definition, references: uses }], file);
+    };
+    p.findRenameLocations = (file, pos, ...rest) => {
+      const at = (f, q) => fn.findRenameLocations(f, q, ...rest);
+      const first = at(file, into(injOf(file), pos));
+      const uses = first && scopedUses(first, at);
+      if (!uses) return result(first, file);
+      return result(uses.map(({ prefixText, suffixText, ...l }) => injOf(l.fileName) ? l : { ...l, prefixText, suffixText }), file);
+    };
+    log(`schematic scope on for ${info.project?.getProjectName?.() ?? "a project"}`);
+    return p;
+  }
+  return { create };
+}
+module.exports = init;

package/package.json

@@ -1,15 +1,45 @@
 {
   "name": "@pcbjs/ts-plugin",
-  "version": "0.0.0",
+  "version": "0.0.1-next.9029beb783788cfbb471cc9d57e1b47864c6eaa6",
   "description": "A TypeScript language service plugin: in a file that passes a schematic module to <PCB schematic={sch}>, every export of that module is in scope by its bare name in the editor, with full types.",
+  "type": "commonjs",
   "license": "MIT",
+  "homepage": "https://pcbjs.dev",
+  "bugs": {
+    "url": "https://github.com/pcbjs/pcbjs/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pcbjs/pcbjs.git",
     "directory": "packages/ts-plugin"
   },
-  "homepage": "https://pcbjs.dev",
+  "main": "./dist/index.cjs",
+  "exports": {
+    ".": {
+      "default": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noEmit && node scripts/bundle.mjs",
+    "test": "npm run build && node --test \"tests/**/*.test.mjs\"",
+    "prepack": "npm run build && node ../../scripts/pack-files.mjs pre",
+    "postpack": "node ../../scripts/pack-files.mjs post"
+  },
+  "devDependencies": {
+    "@pcbjs/compile": "0.0.1-next.9029beb783788cfbb471cc9d57e1b47864c6eaa6",
+    "@types/node": "^24.0.0",
+    "esbuild": "^0.28.0",
+    "typescript": "~5.9.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   }
 }