@kerros/editor 0.0.0-stage → 0.1.0-rc.2

package/dist/import/runs.js

@@ -0,0 +1,67 @@
+const x = 0.02;
+function P(a, p) {
+  const s = [], n = (t, o) => {
+    Math.abs(t[1] - o[1]) < 0.02 ? s.push({ axis: "h", c: (t[1] + o[1]) / 2, lo: Math.min(t[0], o[0]), hi: Math.max(t[0], o[0]) }) : Math.abs(t[0] - o[0]) < 0.02 && s.push({ axis: "v", c: (t[0] + o[0]) / 2, lo: Math.min(t[1], o[1]), hi: Math.max(t[1], o[1]) });
+  };
+  for (const t of a)
+    if (p.test(t.layer) && (t.type === "LINE" && t.a && t.b && n(t.a, t.b), t.type === "POLYLINE" && t.points))
+      for (let o = 1; o < t.points.length; o++) n(t.points[o - 1], t.points[o]);
+  return s.filter((t) => t.hi - t.lo > 0.02);
+}
+function g(a, p, s) {
+  const n = [];
+  for (const t of ["h", "v"]) {
+    const o = a.filter((i) => i.axis === t).sort((i, f) => i.c - f.c || i.lo - f.lo);
+    let e = [];
+    const c = () => {
+      if (!e.length) return;
+      const i = e.reduce((h, l) => h + l.c, 0) / e.length, f = [...e].sort((h, l) => h.lo - l.lo);
+      let M = f[0].lo, r = f[0].hi, u = [];
+      const m = () => n.push({ axis: t, c: i, lo: M, hi: r, gaps: u });
+      for (const h of f.slice(1)) {
+        const l = h.lo - r;
+        l <= 0.02 ? r = Math.max(r, h.hi) : l <= p ? (s && l >= s[0] && l <= s[1] && u.push([r, h.lo]), r = Math.max(r, h.hi)) : (m(), M = h.lo, r = h.hi, u = []);
+      }
+      m();
+    };
+    for (const i of o)
+      e.length && Math.abs(i.c - e[0].c) > 0.02 * 2 && (c(), e = []), e.push(i);
+    c();
+  }
+  return n;
+}
+function E(a, p) {
+  const s = [];
+  for (const n of a)
+    if (p.test(n.layer)) {
+      for (const t of [n.a, n.b, n.at, n.center]) t && s.push(t);
+      for (const t of n.points ?? []) s.push(t);
+    }
+  return s;
+}
+function y(a, p) {
+  const s = [], n = (t, o) => {
+    const e = Math.max(1, Math.ceil(Math.hypot(o[0] - t[0], o[1] - t[1]) / 0.2));
+    for (let c = 0; c <= e; c++) s.push([t[0] + (o[0] - t[0]) * c / e, t[1] + (o[1] - t[1]) * c / e]);
+  };
+  for (const t of a)
+    if (p.test(t.layer)) {
+      if (t.a && t.b && n(t.a, t.b), t.points) for (let o = 1; o < t.points.length; o++) n(t.points[o - 1], t.points[o]);
+      if (t.at && s.push(t.at), t.center && t.r) {
+        const o = (t.start ?? 0) * Math.PI / 180, e = (t.end ?? 360) * Math.PI / 180, c = Math.max(4, Math.ceil(Math.abs(e - o) * t.r / 0.2));
+        for (let i = 0; i <= c; i++) {
+          const f = o + (e - o) * i / c;
+          s.push([t.center[0] + t.r * Math.cos(f), t.center[1] + t.r * Math.sin(f)]);
+        }
+      }
+    }
+  return s;
+}
+export {
+  x as EPS,
+  P as faceSegments,
+  g as mergeRuns,
+  y as symbolPoints,
+  E as symbolVertices
+};
+//# sourceMappingURL=runs.js.map

package/dist/import/runs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.js","sources":["../../../../src/import/runs.ts"],"sourcesContent":["// Axis-aligned runs: the unit the wall reconstruction works in. A \"run\" is a maximal straight\n// stretch of wall face — an axis ('h' along x, 'v' along y), the cross-axis coordinate it sits at,\n// and the interval it covers. Merging collinear fragments into runs, bridging the gaps doors and\n// windows punch through a face, is what turns 93 exterior scribbles into four walls.\nimport type { Point } from '../schema';\nimport type { PlanEntity } from './types';\n\nexport interface FaceSegment {\n  axis: 'h' | 'v';\n  c: number;\n  lo: number;\n  hi: number;\n}\nexport interface Run extends FaceSegment {\n  /** Bridged gaps big enough to be openings, as [lo, hi] along the run. */\n  gaps: [number, number][];\n}\nexport const EPS = 0.02;\n\n/** Axis-aligned LINE/POLYLINE segments on a layer, as face segments. Oblique strokes are ignored —\n *  this importer reads Manhattan drawings. */\nexport function faceSegments(entities: PlanEntity[], layer: RegExp): FaceSegment[] {\n  const out: FaceSegment[] = [];\n  const push = (a: Point, b: Point) => {\n    if (Math.abs(a[1] - b[1]) < EPS)\n      out.push({ axis: 'h', c: (a[1] + b[1]) / 2, lo: Math.min(a[0], b[0]), hi: Math.max(a[0], b[0]) });\n    else if (Math.abs(a[0] - b[0]) < EPS)\n      out.push({ axis: 'v', c: (a[0] + b[0]) / 2, lo: Math.min(a[1], b[1]), hi: Math.max(a[1], b[1]) });\n  };\n  for (const e of entities) {\n    if (!layer.test(e.layer)) continue;\n    if (e.type === 'LINE' && e.a && e.b) push(e.a, e.b);\n    if (e.type === 'POLYLINE' && e.points) for (let i = 1; i < e.points.length; i++) push(e.points[i - 1], e.points[i]);\n  }\n  return out.filter(s => s.hi - s.lo > EPS);\n}\n\n/** Merge collinear fragments into runs, bridging gaps up to `bridge` metres. Gaps in the opening\n *  size range are bridged but remembered — they are the doorways and windows. */\nexport function mergeRuns(segments: FaceSegment[], bridge: number, openingGaps?: [number, number]): Run[] {\n  const out: Run[] = [];\n  for (const axis of ['h', 'v'] as const) {\n    const pool = segments.filter(s => s.axis === axis).sort((x, y) => x.c - y.c || x.lo - y.lo);\n    let group: typeof pool = [];\n    const flush = () => {\n      if (!group.length) return;\n      const c = group.reduce((s, g) => s + g.c, 0) / group.length;\n      const sorted = [...group].sort((x, y) => x.lo - y.lo);\n      let lo = sorted[0].lo,\n        hi = sorted[0].hi;\n      let gaps: [number, number][] = [];\n      const emit = () => out.push({ axis, c, lo, hi, gaps });\n      for (const s of sorted.slice(1)) {\n        const gap = s.lo - hi;\n        if (gap <= EPS) hi = Math.max(hi, s.hi);\n        else if (gap <= bridge) {\n          if (openingGaps && gap >= openingGaps[0] && gap <= openingGaps[1]) gaps.push([hi, s.lo]);\n          hi = Math.max(hi, s.hi);\n        } else {\n          emit();\n          lo = s.lo;\n          hi = s.hi;\n          gaps = [];\n        }\n      }\n      emit();\n    };\n    for (const s of pool) {\n      if (group.length && Math.abs(s.c - group[0].c) > EPS * 2) {\n        flush();\n        group = [];\n      }\n      group.push(s);\n    }\n    flush();\n  }\n  return out;\n}\n\n/** Every point a layer's geometry touches, sampled densely along strokes and arcs — the raw\n *  material for \"is there a door/window symbol standing in this opening?\" scoring. */\n/** A symbol's own vertices, unsampled.\n *\n *  symbolPoints walks every stroke at 20 cm so a door swing reads as a cloud standing in its\n *  opening, which is what finding a door needs. It is the wrong picture of a window: a window is\n *  drawn as a block at each jamb with the glass between them left empty, and the sampling fills that\n *  emptiness in at 20 cm intervals — so the one feature that says where a window begins and ends is\n *  the one thing sampling destroys. Where the shape of the symbol is the information, read the\n *  vertices. */\nexport function symbolVertices(entities: PlanEntity[], layer: RegExp): Point[] {\n  const pts: Point[] = [];\n  for (const e of entities) {\n    if (!layer.test(e.layer)) continue;\n    for (const p of [e.a, e.b, e.at, e.center]) if (p) pts.push(p);\n    for (const p of e.points ?? []) pts.push(p);\n  }\n  return pts;\n}\nexport function symbolPoints(entities: PlanEntity[], layer: RegExp): Point[] {\n  const pts: Point[] = [];\n  const sample = (a: Point, b: Point) => {\n    const n = Math.max(1, Math.ceil(Math.hypot(b[0] - a[0], b[1] - a[1]) / 0.2));\n    for (let i = 0; i <= n; i++) pts.push([a[0] + ((b[0] - a[0]) * i) / n, a[1] + ((b[1] - a[1]) * i) / n]);\n  };\n  for (const e of entities) {\n    if (!layer.test(e.layer)) continue;\n    if (e.a && e.b) sample(e.a, e.b);\n    if (e.points) for (let i = 1; i < e.points.length; i++) sample(e.points[i - 1], e.points[i]);\n    if (e.at) pts.push(e.at);\n    if (e.center && e.r) {\n      const a0 = ((e.start ?? 0) * Math.PI) / 180;\n      const a1 = ((e.end ?? 360) * Math.PI) / 180;\n      const n = Math.max(4, Math.ceil((Math.abs(a1 - a0) * e.r) / 0.2));\n      for (let i = 0; i <= n; i++) {\n        const a = a0 + ((a1 - a0) * i) / n;\n        pts.push([e.center[0] + e.r * Math.cos(a), e.center[1] + e.r * Math.sin(a)]);\n      }\n    }\n  }\n  return pts;\n}\n"],"names":["EPS","faceSegments","entities","layer","out","push","a","b","e","i","s","mergeRuns","segments","bridge","openingGaps","axis","pool","x","y","group","flush","c","g","sorted","lo","hi","gaps","emit","gap","symbolVertices","pts","p","symbolPoints","sample","n","a0","a1"],"mappings":"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"}

package/dist/import/session.js

@@ -0,0 +1,23 @@
+import { readImportCheckpoint as c, readImportBudget as u, readImportPause as d } from "./checkpoint.js";
+import { readTokenUsage as m } from "./usage.js";
+import { mergeImportInstructions as g } from "./instructions.js";
+const a = (t) => `ai-import:${t}:session`;
+async function h(t, s) {
+  var o, r;
+  const n = await t.get(a(s));
+  if (!n) return null;
+  const e = JSON.parse(await n.text());
+  if (e.version !== 1 || e.projectId !== s || !e.sourceId || !Array.isArray(e.messages))
+    throw new Error("The saved import session could not be read.");
+  e.tab && !["setup", "analysis", "activity", "usage"].includes(e.tab) && (e.tab = void 0), e.usage = m(e.usage), e.checkpoint = c(e.checkpoint);
+  const p = new Set((r = (o = e.checkpoint) == null ? void 0 : o.steering) == null ? void 0 : r.map((i) => i.id));
+  return e.pendingInstructions = g(e.pendingInstructions ?? []).filter((i) => !p.has(i.id)), e.budget = u(e.budget), e.pause = d(e.pause), { ...e, phase: e.phase === "running" ? "paused" : e.phase };
+}
+async function b(t, s) {
+  await t.put(a(s.projectId), new Blob([JSON.stringify(s)], { type: "application/json" }));
+}
+export {
+  h as loadAiImportSession,
+  b as saveAiImportSession
+};
+//# sourceMappingURL=session.js.map

package/dist/import/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","sources":["../../../../src/import/session.ts"],"sourcesContent":["import type { AssetRepository } from '../model/types';\nimport {\n  readImportCheckpoint,\n  readImportPause,\n  readImportBudget,\n  type ImportCheckpoint,\n  type ImportBudget,\n  type ImportPause,\n} from './checkpoint';\nimport { readTokenUsage, type AiTokenUsage } from './usage';\nimport { mergeImportInstructions } from './instructions';\n\nexport interface AiImportSession {\n  version: 1;\n  projectId: string;\n  sourceId: string;\n  sourceName: string;\n  sourceType: string;\n  instructions: string;\n  brief?: import('./brief').ImportBrief;\n  followUp: string;\n  tab?: 'setup' | 'analysis' | 'activity' | 'usage';\n  pendingInstructions?: import('./instructions').ImportInstruction[];\n  checkpoint?: ImportCheckpoint;\n  budget?: ImportBudget;\n  pause?: ImportPause;\n  messages: { type: 'text' | 'tool' | 'user'; detail: string; instructionId?: string }[];\n  phase: 'running' | 'done' | 'paused' | 'failed';\n  activity: string;\n  edits: number;\n  usage: AiTokenUsage;\n  hasUsage: boolean;\n  error: string;\n}\n\nconst key = (projectId: string) => `ai-import:${projectId}:session`;\n\n/** Import state belongs to the host's asset store, alongside the original drawing. It is not\n * another plan: all geometry lives in the normal project repository. */\nexport async function loadAiImportSession(assets: AssetRepository, projectId: string): Promise<AiImportSession | null> {\n  const blob = await assets.get(key(projectId));\n  if (!blob) return null;\n  const value = JSON.parse(await blob.text()) as AiImportSession;\n  if (value.version !== 1 || value.projectId !== projectId || !value.sourceId || !Array.isArray(value.messages))\n    throw new Error('The saved import session could not be read.');\n  if (value.tab && !['setup', 'analysis', 'activity', 'usage'].includes(value.tab)) value.tab = undefined;\n  value.usage = readTokenUsage(value.usage);\n  value.checkpoint = readImportCheckpoint(value.checkpoint);\n  const received = new Set(value.checkpoint?.steering?.map(m => m.id));\n  value.pendingInstructions = mergeImportInstructions(value.pendingInstructions ?? []).filter(m => !received.has(m.id));\n  value.budget = readImportBudget(value.budget);\n  value.pause = readImportPause(value.pause);\n  // A reload disconnects/cancels the backend request. Resuming is an explicit paid action.\n  return { ...value, phase: value.phase === 'running' ? 'paused' : value.phase };\n}\n\nexport async function saveAiImportSession(assets: AssetRepository, session: AiImportSession): Promise<void> {\n  await assets.put(key(session.projectId), new Blob([JSON.stringify(session)], { type: 'application/json' }));\n}\n"],"names":["key","projectId","loadAiImportSession","assets","blob","value","readTokenUsage","readImportCheckpoint","received","_b","_a","m","mergeImportInstructions","readImportBudget","readImportPause","saveAiImportSession","session"],"mappings":";;;AAmCA,MAAMA,IAAM,CAACC,MAAsB,aAAaA,CAAS;AAIzD,eAAsBC,EAAoBC,GAAyBF,GAAoD;;AACrH,QAAMG,IAAO,MAAMD,EAAO,IAAIH,EAAIC,CAAS,CAAC;AAC5C,MAAI,CAACG,EAAM,QAAO;AAClB,QAAMC,IAAQ,KAAK,MAAM,MAAMD,EAAK,MAAM;AAC1C,MAAIC,EAAM,YAAY,KAAKA,EAAM,cAAcJ,KAAa,CAACI,EAAM,YAAY,CAAC,MAAM,QAAQA,EAAM,QAAQ;AAC1G,UAAM,IAAI,MAAM,6CAA6C;AAC/D,EAAIA,EAAM,OAAO,CAAC,CAAC,SAAS,YAAY,YAAY,OAAO,EAAE,SAASA,EAAM,GAAG,QAAS,MAAM,SAC9FA,EAAM,QAAQC,EAAeD,EAAM,KAAK,GACxCA,EAAM,aAAaE,EAAqBF,EAAM,UAAU;AACxD,QAAMG,IAAW,IAAI,KAAIC,KAAAC,IAAAL,EAAM,eAAN,gBAAAK,EAAkB,aAAlB,gBAAAD,EAA4B,IAAI,CAAAE,MAAKA,EAAE,GAAG;AACnE,SAAAN,EAAM,sBAAsBO,EAAwBP,EAAM,uBAAuB,CAAA,CAAE,EAAE,OAAO,CAAAM,MAAK,CAACH,EAAS,IAAIG,EAAE,EAAE,CAAC,GACpHN,EAAM,SAASQ,EAAiBR,EAAM,MAAM,GAC5CA,EAAM,QAAQS,EAAgBT,EAAM,KAAK,GAElC,EAAE,GAAGA,GAAO,OAAOA,EAAM,UAAU,YAAY,WAAWA,EAAM,MAAA;AACzE;AAEA,eAAsBU,EAAoBZ,GAAyBa,GAAyC;AAC1G,QAAMb,EAAO,IAAIH,EAAIgB,EAAQ,SAAS,GAAG,IAAI,KAAK,CAAC,KAAK,UAAUA,CAAO,CAAC,GAAG,EAAE,MAAM,mBAAA,CAAoB,CAAC;AAC5G;"}

package/dist/import/types.js

@@ -0,0 +1,13 @@
+const _ = {
+  exteriorFace: /^12_/,
+  interiorFace: /^13_/,
+  partitionFaces: /^(186_|196_)/,
+  doors: /^27_/,
+  windows: /^26_/,
+  labels: /^55_/,
+  stairs: /^82_/
+};
+export {
+  _ as VERTEX_LAYERS
+};
+//# sourceMappingURL=types.js.map

package/dist/import/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../../src/import/types.ts"],"sourcesContent":["// The plan-import contract: what a normalized drawing entity looks like, which layers mean what,\n// and what an import reports back. Everything here is data; the geometry lives in runs.ts/walls.ts\n// and the orchestration in planImport.ts.\nimport type { Point } from '../schema';\n\n/** One normalized drawing entity, coordinates in metres. The shape scripts/plan-import/extract.mjs\n *  emits with `--expand --units m`; hosts producing entities elsewhere target this. */\nexport interface PlanEntity {\n  type: 'LINE' | 'POLYLINE' | 'ARC' | 'CIRCLE' | 'TEXT' | 'INSERT' | 'DIMENSION' | 'POINT';\n  layer: string;\n  a?: Point;\n  b?: Point;\n  points?: Point[];\n  closed?: boolean;\n  center?: Point;\n  r?: number;\n  start?: number;\n  end?: number;\n  at?: Point;\n  text?: string;\n  h?: number;\n  block?: string;\n  rotation?: number;\n}\n\n/** Which layers carry what. Defaults are the Vertex-style numbered taxonomy; override per source. */\nexport interface PlanLayerMap {\n  /** Outside face of the building envelope. */\n  exteriorFace: RegExp;\n  /** Inside face of the envelope — also the outline the interior plate is traced from. */\n  interiorFace: RegExp;\n  /** Interior wall face layers; each wall is a pair of parallel runs within these. */\n  partitionFaces: RegExp;\n  /** Door symbol geometry (leaves, swings). Decides whether a wall gap is a doorway. */\n  doors: RegExp;\n  /** Window symbol geometry. Decides whether a wall gap is a window. */\n  windows: RegExp;\n  /** Room label texts. Area figures (pure numbers) are ignored automatically. */\n  labels: RegExp;\n  /** Stair treads. Optional: a sheet with no stair on it simply has none, which is a fact about the\n   *  building and not a failure. Where it is drawn, the symbol's extent is the flight's footprint. */\n  stairs?: RegExp;\n}\nexport const VERTEX_LAYERS: PlanLayerMap = {\n  exteriorFace: /^12_/,\n  interiorFace: /^13_/,\n  partitionFaces: /^(186_|196_)/,\n  doors: /^27_/,\n  windows: /^26_/,\n  labels: /^55_/,\n  stairs: /^82_/,\n};\n\nexport interface PlanImportOptions {\n  floorId: string | null;\n  layers?: PlanLayerMap;\n}\nexport interface PlanImportReport {\n  walls: number;\n  /** Flights of stairs read off the drawing. */\n  stairs: number;\n  rooms: number;\n  doors: number;\n  windows: number;\n  /** Doorless openings — stretches where the wall was split rather than sealed. */\n  passages: number;\n  named: number;\n  /** Things the drawing suggested but the import declined, each with the reason. */\n  skipped: string[];\n}\n"],"names":["VERTEX_LAYERS"],"mappings":"AA2CO,MAAMA,IAA8B;AAAA,EACzC,cAAc;AAAA,EACd,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,OAAO;AAAA,EACP,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AACV;"}

package/dist/import/usage.js

@@ -0,0 +1,29 @@
+const s = () => ({
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0
+});
+function c(e, o) {
+  return {
+    inputTokens: e.inputTokens + o.inputTokens,
+    outputTokens: e.outputTokens + o.outputTokens,
+    cacheReadTokens: e.cacheReadTokens + o.cacheReadTokens,
+    cacheWriteTokens: e.cacheWriteTokens + o.cacheWriteTokens
+  };
+}
+function r(e) {
+  if (!e || typeof e != "object") throw new Error("Invalid import token usage.");
+  const o = e, t = s();
+  for (const n of Object.keys(t)) {
+    if (!Number.isSafeInteger(o[n]) || o[n] < 0) throw new Error("Invalid import token usage.");
+    t[n] = o[n];
+  }
+  return t;
+}
+export {
+  c as addTokenUsage,
+  s as emptyTokenUsage,
+  r as readTokenUsage
+};
+//# sourceMappingURL=usage.js.map

package/dist/import/usage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.js","sources":["../../../../src/import/usage.ts"],"sourcesContent":["/** Disjoint provider-reported token counts. Input excludes cache reads and writes. */\nexport interface AiTokenUsage {\n  inputTokens: number;\n  outputTokens: number;\n  cacheReadTokens: number;\n  cacheWriteTokens: number;\n}\nexport const emptyTokenUsage = (): AiTokenUsage => ({\n  inputTokens: 0,\n  outputTokens: 0,\n  cacheReadTokens: 0,\n  cacheWriteTokens: 0,\n});\nexport function addTokenUsage(a: AiTokenUsage, b: AiTokenUsage): AiTokenUsage {\n  return {\n    inputTokens: a.inputTokens + b.inputTokens,\n    outputTokens: a.outputTokens + b.outputTokens,\n    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,\n    cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,\n  };\n}\nexport function readTokenUsage(value: unknown): AiTokenUsage {\n  if (!value || typeof value !== 'object') throw new Error('Invalid import token usage.');\n  const usage = value as AiTokenUsage;\n  const result = emptyTokenUsage();\n  for (const key of Object.keys(result) as (keyof AiTokenUsage)[]) {\n    if (!Number.isSafeInteger(usage[key]) || usage[key] < 0) throw new Error('Invalid import token usage.');\n    result[key] = usage[key];\n  }\n  return result;\n}\n"],"names":["emptyTokenUsage","addTokenUsage","a","b","readTokenUsage","value","usage","result","key"],"mappings":"AAOO,MAAMA,IAAkB,OAAqB;AAAA,EAClD,aAAa;AAAA,EACb,cAAc;AAAA,EACd,iBAAiB;AAAA,EACjB,kBAAkB;AACpB;AACO,SAASC,EAAcC,GAAiBC,GAA+B;AAC5E,SAAO;AAAA,IACL,aAAaD,EAAE,cAAcC,EAAE;AAAA,IAC/B,cAAcD,EAAE,eAAeC,EAAE;AAAA,IACjC,iBAAiBD,EAAE,kBAAkBC,EAAE;AAAA,IACvC,kBAAkBD,EAAE,mBAAmBC,EAAE;AAAA,EAAA;AAE7C;AACO,SAASC,EAAeC,GAA8B;AAC3D,MAAI,CAACA,KAAS,OAAOA,KAAU,SAAU,OAAM,IAAI,MAAM,6BAA6B;AACtF,QAAMC,IAAQD,GACRE,IAASP,EAAA;AACf,aAAWQ,KAAO,OAAO,KAAKD,CAAM,GAA6B;AAC/D,QAAI,CAAC,OAAO,cAAcD,EAAME,CAAG,CAAC,KAAKF,EAAME,CAAG,IAAI,EAAG,OAAM,IAAI,MAAM,6BAA6B;AACtG,IAAAD,EAAOC,CAAG,IAAIF,EAAME,CAAG;AAAA,EACzB;AACA,SAAOD;AACT;"}

package/dist/import/walls.js

@@ -0,0 +1,112 @@
+import "polygon-clipping";
+import { MIN_SEGMENT as d } from "../model/geometry.js";
+function g(c, r, h, t, l, u = "both", i = "union") {
+  const n = [], o = /* @__PURE__ */ new Set();
+  for (const a of c) {
+    if (o.has(a)) continue;
+    let s = null;
+    for (const f of r) {
+      if (f === a || o.has(f) || f.axis !== a.axis) continue;
+      const e = Math.abs(f.c - a.c);
+      e < h || e > t || Math.min(a.hi, f.hi) - Math.max(a.lo, f.lo) < l || (!s || e < s.t) && (s = { other: f, t: e });
+    }
+    if (!s) continue;
+    o.add(a), o.add(s.other);
+    const M = u === "both" ? a.gaps.filter((f) => s.other.gaps.some((e) => Math.max(f[0], e[0]) < Math.min(f[1], e[1]))) : [
+      ...a.gaps,
+      ...s.other.gaps.filter((f) => !a.gaps.some((e) => Math.max(e[0], f[0]) < Math.min(e[1], f[1])))
+    ];
+    n.push({
+      axis: a.axis,
+      c: (a.c + s.other.c) / 2,
+      lo: i === "union" ? Math.min(a.lo, s.other.lo) : Math.max(a.lo, s.other.lo),
+      hi: i === "union" ? Math.max(a.hi, s.other.hi) : Math.min(a.hi, s.other.hi),
+      thickness: Math.round(s.t * 1e3) / 1e3,
+      gaps: M.map((f) => [...f])
+    });
+  }
+  return x(n);
+}
+function x(c) {
+  const r = [];
+  for (const h of c) {
+    const t = r.find(
+      (i) => i.axis === h.axis && // Bodies intersect across the wall, not merely run near each other.
+      Math.abs(i.c - h.c) < (i.thickness + h.thickness) / 2 - 1e-6 && // …and they cover the same stretch along it.
+      Math.min(i.hi, h.hi) - Math.max(i.lo, h.lo) > 0
+    );
+    if (!t) {
+      r.push(h);
+      continue;
+    }
+    const l = Math.min(t.c - t.thickness / 2, h.c - h.thickness / 2), u = Math.max(t.c + t.thickness / 2, h.c + h.thickness / 2);
+    t.c = (l + u) / 2, t.thickness = Math.round((u - l) * 1e3) / 1e3, t.lo = Math.min(t.lo, h.lo), t.hi = Math.max(t.hi, h.hi), t.gaps = t.gaps.filter((i) => h.gaps.some((n) => Math.max(i[0], n[0]) < Math.min(i[1], n[1])));
+  }
+  return r;
+}
+const k = (c, r) => c.axis === "h" ? [r, c.c] : [c.c, r];
+function E(c, r) {
+  const h = c.gaps.find((t) => Math.max(t[0], r[0]) < Math.min(t[1], r[1]));
+  h ? (h[0] = Math.min(h[0], r[0]), h[1] = Math.max(h[1], r[1])) : c.gaps.push([...r]);
+}
+function N(c, r, h = 0.45) {
+  for (const t of c)
+    for (const l of ["lo", "hi"]) {
+      const i = r.filter((o) => o !== t && o.axis !== t.axis && t.c > o.lo - 0.3 && t.c < o.hi + 0.3).map((o) => ({ c: o.c, d: Math.abs(o.c - t[l]) })).sort((o, a) => o.d - a.d)[0];
+      if (!i || i.d > h || i.d < 5e-3) continue;
+      const n = { ...t, [l]: i.c };
+      n.hi - n.lo > d && (t[l] = i.c);
+    }
+  for (const t of r) {
+    const l = [];
+    for (const n of c)
+      if (!(n.axis === t.axis || n.c <= t.lo + 0.01 || n.c >= t.hi - 0.01))
+        for (const o of ["lo", "hi"]) Math.abs(n[o] - t.c) < 0.01 && l.push({ w: n, end: o, at: n.c });
+    const u = (n) => n.w.gaps.some((o) => Math.min(Math.abs(o[0] - n.w[n.end]), Math.abs(o[1] - n.w[n.end])) < 1), i = [...l].sort(
+      (n, o) => Number(u(n)) - Number(u(o)) || n.w.thickness - o.w.thickness || o.at - n.at
+    );
+    for (const n of i) {
+      if (Math.abs(n.w[n.end] - t.c) > 0.01) continue;
+      const o = [t.lo, t.hi, ...l.filter((e) => e !== n && Math.abs(e.w[e.end] - t.c) < 0.01).map((e) => e.at)];
+      if (Math.min(...o.filter((e) => Math.abs(e - n.at) > 1e-9).map((e) => Math.abs(e - n.at))) >= d) continue;
+      const s = t.thickness / 2 + 0.01, M = n.end === "lo" ? t.c + s : t.c - s, f = { ...n.w, [n.end]: M };
+      f.hi - f.lo > d && (n.w[n.end] = M);
+    }
+  }
+}
+function S(c) {
+  for (const r of c) {
+    const h = c.filter((t) => t.axis !== r.axis);
+    for (const t of ["lo", "hi"]) {
+      const l = h.map((u) => ({ o: u, d: Math.abs(u.c - r[t]) })).sort((u, i) => u.d - i.d)[0];
+      l && l.d < 0.8 && (r[t] = l.o.c);
+    }
+  }
+}
+function w(c) {
+  if (c.length < 4) return null;
+  const r = c.reduce((a, s) => a + (s.axis === "v" ? s.c : (s.lo + s.hi) / 2), 0) / c.length, h = c.reduce((a, s) => a + (s.axis === "h" ? s.c : (s.lo + s.hi) / 2), 0) / c.length, t = (a) => {
+    const s = a.axis === "h" ? Math.sign(h - a.c) : Math.sign(r - a.c);
+    return a.c + (s || 1) * (a.thickness / 2);
+  }, l = (a, s, M) => Math.abs(M.c - s) < 0.8 && (Math.abs(M.lo - a.c) < 0.8 || Math.abs(M.hi - a.c) < 0.8), u = new Set(c);
+  let i = c[0];
+  u.delete(i);
+  let n = i.hi;
+  const o = [];
+  for (let a = 0; a < c.length; a++) {
+    const s = [...u].filter((e) => e.axis !== i.axis && l(i, n, e)).sort((e, m) => Math.abs(e.c - n) - Math.abs(m.c - n))[0], M = !s && !u.size && l(i, n, c[0]), f = s ?? (M ? c[0] : null);
+    if (!f) return null;
+    if (o.push(i.axis === "h" ? [t(f), t(i)] : [t(i), t(f)]), !s) break;
+    n = Math.abs(s.lo - i.c) < Math.abs(s.hi - i.c) ? s.hi : s.lo, i = s, u.delete(i);
+  }
+  return u.size || o.length < 4 ? null : o;
+}
+export {
+  E as addGap,
+  k as along,
+  S as closeCorners,
+  g as pairWalls,
+  N as snapEnds,
+  w as traceRing
+};
+//# sourceMappingURL=walls.js.map

package/dist/import/walls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walls.js","sources":["../../../../src/import/walls.ts"],"sourcesContent":["// Wall reconstruction: face runs pair into walls, walls chain into the envelope ring. Pure\n// geometry over runs.ts — nothing here touches a ProjectDocument.\nimport { MIN_SEGMENT } from '../schema';\nimport type { Point } from '../schema';\nimport type { Run } from './runs';\n\nexport interface Wall {\n  axis: 'h' | 'v';\n  c: number;\n  lo: number;\n  hi: number;\n  thickness: number;\n  gaps: [number, number][];\n}\n\n/** Pair opposing face runs into walls: same axis, cross-distance within a wall thickness, intervals\n *  overlapping. The wall sits on the centreline. `gapMode` decides what counts as an opening: for\n *  partitions both faces must break ('both'); for the envelope the silhouette line is often drawn\n *  continuous, so a break in either face counts ('either'). */\nexport function pairWalls(\n  a: Run[],\n  b: Run[],\n  minT: number,\n  maxT: number,\n  minOverlap: number,\n  gapMode: 'both' | 'either' = 'both',\n  /** Wall extent from the pair: 'union' for the envelope (its faces fragment unevenly and corners\n   *  are closed afterwards); 'overlap' for partitions — a wall exists only where BOTH faces do,\n   *  and taking the union would stretch it over stretches where a lone line means something else. */\n  extentMode: 'union' | 'overlap' = 'union',\n): Wall[] {\n  const walls: Wall[] = [];\n  const used = new Set<Run>();\n  for (const one of a) {\n    if (used.has(one)) continue;\n    let best: { other: Run; t: number } | null = null;\n    for (const other of b) {\n      if (other === one || used.has(other) || other.axis !== one.axis) continue;\n      const t = Math.abs(other.c - one.c);\n      if (t < minT || t > maxT) continue;\n      const overlap = Math.min(one.hi, other.hi) - Math.max(one.lo, other.lo);\n      if (overlap < minOverlap) continue;\n      if (!best || t < best.t) best = { other, t };\n    }\n    if (!best) continue;\n    used.add(one);\n    used.add(best.other);\n    const gaps =\n      gapMode === 'both'\n        ? one.gaps.filter(g => best!.other.gaps.some(h => Math.max(g[0], h[0]) < Math.min(g[1], h[1])))\n        : [\n            ...one.gaps,\n            ...best.other.gaps.filter(h => !one.gaps.some(g => Math.max(g[0], h[0]) < Math.min(g[1], h[1]))),\n          ];\n    walls.push({\n      axis: one.axis,\n      c: (one.c + best.other.c) / 2,\n      lo: extentMode === 'union' ? Math.min(one.lo, best.other.lo) : Math.max(one.lo, best.other.lo),\n      hi: extentMode === 'union' ? Math.max(one.hi, best.other.hi) : Math.min(one.hi, best.other.hi),\n      thickness: Math.round(best.t * 1000) / 1000,\n      gaps: gaps.map(g => [...g] as [number, number]),\n    });\n  }\n  return mergeSolids(walls);\n}\n\n/** Collapse walls whose bodies occupy the same space into one spanning the outermost faces.\n *\n *  Pairing consumes each run once and takes the nearest partner, which is right when a wall is drawn\n *  as exactly two face lines. Some offices draw four — sheathing, both sides of the stud frame, and\n *  the inner lining — and those pair up as two thin walls standing inside each other. Two walls\n *  cannot occupy the same volume, so where the bodies overlap the drawing meant one wall, and its\n *  faces are the outermost lines. On a two-line drawing no two walls overlap and this does nothing. */\nfunction mergeSolids(walls: Wall[]): Wall[] {\n  const out: Wall[] = [];\n  for (const w of walls) {\n    const host = out.find(\n      o =>\n        o.axis === w.axis &&\n        // Bodies intersect across the wall, not merely run near each other.\n        Math.abs(o.c - w.c) < (o.thickness + w.thickness) / 2 - 1e-6 &&\n        // …and they cover the same stretch along it.\n        Math.min(o.hi, w.hi) - Math.max(o.lo, w.lo) > 0,\n    );\n    if (!host) {\n      out.push(w);\n      continue;\n    }\n    const lo = Math.min(host.c - host.thickness / 2, w.c - w.thickness / 2);\n    const hi = Math.max(host.c + host.thickness / 2, w.c + w.thickness / 2);\n    host.c = (lo + hi) / 2;\n    host.thickness = Math.round((hi - lo) * 1000) / 1000;\n    host.lo = Math.min(host.lo, w.lo);\n    host.hi = Math.max(host.hi, w.hi);\n    // An opening is only an opening where both readings agree it is one.\n    host.gaps = host.gaps.filter(g => w.gaps.some(h => Math.max(g[0], h[0]) < Math.min(g[1], h[1])));\n  }\n  return out;\n}\n\nexport const wallEnds = (w: Wall): [Point, Point] =>\n  w.axis === 'h'\n    ? [\n        [w.lo, w.c],\n        [w.hi, w.c],\n      ]\n    : [\n        [w.c, w.lo],\n        [w.c, w.hi],\n      ];\nexport const along = (w: Wall, t: number): Point => (w.axis === 'h' ? [t, w.c] : [w.c, t]);\n\n/** Merge an opening gap into a wall, unioning with any gap it overlaps — both faces usually report\n *  the same opening at slightly different extents, and it must become ONE opening. */\nexport function addGap(w: Wall, gap: [number, number]) {\n  const twin = w.gaps.find(g => Math.max(g[0], gap[0]) < Math.min(g[1], gap[1]));\n  if (twin) {\n    twin[0] = Math.min(twin[0], gap[0]);\n    twin[1] = Math.max(twin[1], gap[1]);\n  } else w.gaps.push([...gap]);\n}\n\n/** Snap wall ends onto the centreline of the perpendicular wall they meet. CAD face lines are\n *  drawn to the crossing wall's far face — or stop at its near one — so raw run extents overshoot\n *  or undershoot T-junctions by half a thickness. Landing exactly on the centreline is what a\n *  hand-drawn wall does in the editor, and it is what lets rendered caps disappear inside the\n *  crossing wall instead of poking past it. */\nexport function snapEnds(walls: Wall[], targets: Wall[], tolerance = 0.45) {\n  for (const w of walls) {\n    for (const end of ['lo', 'hi'] as const) {\n      const candidates = targets\n        .filter(t => t !== w && t.axis !== w.axis && w.c > t.lo - 0.3 && w.c < t.hi + 0.3)\n        .map(t => ({ c: t.c, d: Math.abs(t.c - w[end]) }))\n        .sort((x, y) => x.d - y.d);\n      const near = candidates[0];\n      if (!near || near.d > tolerance || near.d < 0.005) continue;\n      const next = { ...w, [end]: near.c } as Wall;\n      if (next.hi - next.lo > MIN_SEGMENT) w[end] = near.c;\n    }\n  }\n  // An end landing on a wall's centreline welds a junction there and splits the wall (joinAt), so\n  // two T-ends closer together than a legal segment — a staggered junction — would leave\n  // sub-MIN_SEGMENT debris the document refuses. Retract such an end to the target's near FACE\n  // instead: visually flush, hidden under the crossing wall's stroke, but far enough off the\n  // centreline that no junction welds.\n  for (const t of targets) {\n    const tees: { w: Wall; end: 'lo' | 'hi'; at: number }[] = [];\n    for (const w of walls) {\n      if (w.axis === t.axis || w.c <= t.lo + 0.01 || w.c >= t.hi - 0.01) continue;\n      for (const end of ['lo', 'hi'] as const) if (Math.abs(w[end] - t.c) < 0.01) tees.push({ w, end, at: w.c });\n    }\n    // Retract one end at a time and re-check: a staggered pair needs only ONE of its two ends\n    // pulled back to make the junctions legal, and the one to keep welded is the end whose wall\n    // has an opening close by — a retracted end eats into the clearance that opening needs.\n    const gapNearEnd = (x: (typeof tees)[number]) =>\n      x.w.gaps.some(g => Math.min(Math.abs(g[0] - x.w[x.end]), Math.abs(g[1] - x.w[x.end])) < 1);\n    const pending = [...tees].sort(\n      (x, y) => Number(gapNearEnd(x)) - Number(gapNearEnd(y)) || x.w.thickness - y.w.thickness || y.at - x.at,\n    );\n    for (const tee of pending) {\n      if (Math.abs(tee.w[tee.end] - t.c) > 0.01) continue; // already retracted\n      const points = [t.lo, t.hi, ...tees.filter(x => x !== tee && Math.abs(x.w[x.end] - t.c) < 0.01).map(x => x.at)];\n      const nearest = Math.min(...points.filter(p => Math.abs(p - tee.at) > 1e-9).map(p => Math.abs(p - tee.at)));\n      if (nearest >= MIN_SEGMENT) continue;\n      const back = t.thickness / 2 + 0.01;\n      const retracted = tee.end === 'lo' ? t.c + back : t.c - back;\n      const next = { ...tee.w, [tee.end]: retracted } as Wall;\n      if (next.hi - next.lo > MIN_SEGMENT) tee.w[tee.end] = retracted;\n    }\n  }\n}\n\n/** Extend each envelope wall to the centreline of its perpendicular neighbours, closing corners. */\nexport function closeCorners(envelope: Wall[]) {\n  for (const w of envelope) {\n    const perpendicular = envelope.filter(o => o.axis !== w.axis);\n    for (const end of ['lo', 'hi'] as const) {\n      const near = perpendicular.map(o => ({ o, d: Math.abs(o.c - w[end]) })).sort((x, y) => x.d - y.d)[0];\n      if (near && near.d < 0.8) w[end] = near.o.c;\n    }\n  }\n}\n\n/** Chain envelope walls into the closed inner-face ring. Each corner is the intersection of two\n *  adjacent walls' INNER faces (centreline offset half a thickness toward the building), so the\n *  plate is the actual floor area, not the wall footprint. Handles L and T footprints; returns\n *  null when the walls do not close into one loop. */\nexport function traceRing(envelope: Wall[]): Point[] | null {\n  if (envelope.length < 4) return null;\n  const cx = envelope.reduce((s, w) => s + (w.axis === 'v' ? w.c : (w.lo + w.hi) / 2), 0) / envelope.length;\n  const cy = envelope.reduce((s, w) => s + (w.axis === 'h' ? w.c : (w.lo + w.hi) / 2), 0) / envelope.length;\n  const innerC = (w: Wall) => {\n    const towards = w.axis === 'h' ? Math.sign(cy - w.c) : Math.sign(cx - w.c);\n    return w.c + (towards || 1) * (w.thickness / 2);\n  };\n  // Adjacency: two perpendicular walls meet when each one's centreline lies near an END of the\n  // other's interval. Walk the loop by always leaving through the end we did not enter by.\n  const meets = (a: Wall, end: number, b: Wall) =>\n    Math.abs(b.c - end) < 0.8 && (Math.abs(b.lo - a.c) < 0.8 || Math.abs(b.hi - a.c) < 0.8);\n  const unvisited = new Set(envelope);\n  let current = envelope[0];\n  unvisited.delete(current);\n  let exitEnd = current.hi;\n  const ring: Point[] = [];\n  for (let steps = 0; steps < envelope.length; steps++) {\n    const next = [...unvisited]\n      .filter(w => w.axis !== current.axis && meets(current, exitEnd, w))\n      .sort((x, y) => Math.abs(x.c - exitEnd) - Math.abs(y.c - exitEnd))[0];\n    const closes = !next && !unvisited.size && meets(current, exitEnd, envelope[0]);\n    const partner = next ?? (closes ? envelope[0] : null);\n    if (!partner) return null;\n    ring.push(current.axis === 'h' ? [innerC(partner), innerC(current)] : [innerC(current), innerC(partner)]);\n    if (!next) break;\n    // Enter `next` at the end near the wall we came from; leave through the other one.\n    exitEnd = Math.abs(next.lo - current.c) < Math.abs(next.hi - current.c) ? next.hi : next.lo;\n    current = next;\n    unvisited.delete(current);\n  }\n  if (unvisited.size || ring.length < 4) return null;\n  return ring;\n}\n"],"names":["pairWalls","a","b","minT","maxT","minOverlap","gapMode","extentMode","walls","used","one","best","other","t","gaps","g","h","mergeSolids","out","w","host","o","lo","hi","along","addGap","gap","twin","snapEnds","targets","tolerance","end","near","x","y","next","MIN_SEGMENT","tees","gapNearEnd","pending","tee","points","p","back","retracted","closeCorners","envelope","perpendicular","traceRing","cx","s","cy","innerC","towards","meets","unvisited","current","exitEnd","ring","steps","closes","partner"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,178 @@
+import { SitePlanner as r, SiteViewer as t } from "./SitePlanner.js";
+import { IndexedAssetRepository as i, IndexedProjectRepository as s, LocalProjectRepository as n } from "./adapters/persistence.js";
+import { neutralBasemap as d } from "./adapters/basemap.js";
+import { KerrosThemeProvider as f, useDarkMode as m, useKerrosTheme as l, useStrings as E } from "./theme/index.js";
+import { enclosedRegion as R, enclosedRegions as u, inSpace as x, refitEnclosedRooms as P, spaceAt as v, spacePoint as S, spaces as y } from "./model/spaces.js";
+import { addPortalGroup as O, addZone as T, captive as A, entryInto as _, nestZone as L, perimeter as b, pruneOntology as B, removePortalGroup as I, removeZone as N, setPortalGroupMembers as j, setZoneMembers as M, zoneSpaces as V } from "./model/ontology.js";
+import { divideSpaces as F, inferOpenBoundaries as C, inferPortals as G, mergeSpaces as w, refreshPortals as K, spacesDividedBy as Z, spacesRejoinedBy as z } from "./model/inference.js";
+import { derivedGraph as U } from "./model/topology.js";
+import { effectivePortals as X, sharedBoundaryPortals as Y } from "./model/portals.js";
+import { OBJECT_KINDS as W, isArea as q, isDevice as Q, isOpening as $, isSpace as ee, uid as oe } from "./model/types.js";
+import { createObject as te, emptyProject as ae } from "./model/factory.js";
+import { addBoundaryHole as se, addVirtualBoundary as ne, bindSpaceToRegion as pe, boundaryEdges as de, boundaryRegionAt as ce, boundaryRegions as fe, boundaryRings as me, connectSpace as le, derivedSpaceRings as Ee, disconnectSpace as ge, drawVirtualBoundary as Re, followsBoundaries as ue, normalizeBoundaries as xe, refreshBoundarySpaces as Pe } from "./model/boundaries.js";
+import { DEFAULT_FOV as Se, DEFAULT_RANGE as ye, coverageOf as he } from "./model/coverage.js";
+import { copyProject as Te, openingFloorId as Ae } from "./model/project.js";
+import { MIN_SEGMENT as Le, OPENING_MIN_SEGMENT as be, addBarrier as Be, barrierEnds as Ie, centroid as Ne, closeRing as je, distance as Me, duplicateFloor as Ve, footprint as De, geoOrigin as Fe, moveOrigin as Ce, objectArea as Ge, objectPosition as we, objectRotation as Ke, openRing as Ze, pointInRing as ze, rectangle as He, removeFloor as Ue, ringArea as ke, rotate as Xe, segmentProjection as Ye, segmentsCross as Je, slopeElevation as We, toLngLat as qe, toLocal as Qe } from "./model/geometry.js";
+import { blobDataUrl as eo, exportProject as oo, importProject as ro, parseExport as to } from "./model/document.js";
+import { COORD_LIMIT as io, freezeProject as so, transact as no, validateNavigation as po, validateProject as co, validateRelationships as fo, validateRings as mo } from "./model/validate.js";
+import { applyMutation as Eo, applyMutations as go } from "./model/mutations.js";
+import { DOOR_COST as uo, ELEVATOR_BASE as xo, ELEVATOR_PER_METRE as Po, HERE as vo, NAV_WELD as So, STAIR_CLIMB_FACTOR as yo, addNavEdge as ho, addNavNode as Oo, chainVertical as To, edgeCost as Ao, edgeLength as _o, findRoute as Lo, floorPhrase as bo, navEdges as Bo, navNodes as Io, navPath as No, routeAnchors as jo, routeSteps as Mo } from "./model/navigation.js";
+import { EXTERIOR_PRESETS as Do } from "./model/materials.js";
+import { PITCH as Co, flights as Go, flightsAt as wo, isVertical as Ko, passesThrough as Zo, pitchOf as zo, primaryShafts as Ho, reaches as Uo, runFor as ko, servedFloors as Xo, shaftKey as Yo, shaftVoids as Jo, span as Wo } from "./model/vertical.js";
+import { buildRoomNavigation as Qo } from "./model/roomNavigation.js";
+import { importPlanEntities as er } from "./import/planImport.js";
+import { VERTEX_LAYERS as rr } from "./import/types.js";
+import { LAYER_ROLES as ar, detectLayers as ir, layerPattern as sr } from "./import/detect.js";
+import { documentSvg as pr } from "./import/documentSvg.js";
+import { landmarks as cr, sheetOffset as fr, shiftEntities as mr } from "./import/register.js";
+import { StructureView as Er } from "./components/StructureView.js";
+export {
+  io as COORD_LIMIT,
+  Se as DEFAULT_FOV,
+  ye as DEFAULT_RANGE,
+  uo as DOOR_COST,
+  xo as ELEVATOR_BASE,
+  Po as ELEVATOR_PER_METRE,
+  Do as EXTERIOR_PRESETS,
+  r as FloorEditor,
+  vo as HERE,
+  i as IndexedAssetRepository,
+  s as IndexedProjectRepository,
+  f as KerrosThemeProvider,
+  ar as LAYER_ROLES,
+  n as LocalProjectRepository,
+  Le as MIN_SEGMENT,
+  So as NAV_WELD,
+  W as OBJECT_KINDS,
+  be as OPENING_MIN_SEGMENT,
+  Co as PITCH,
+  yo as STAIR_CLIMB_FACTOR,
+  t as SiteViewer,
+  Er as StructureView,
+  rr as VERTEX_LAYERS,
+  Be as addBarrier,
+  se as addBoundaryHole,
+  ho as addNavEdge,
+  Oo as addNavNode,
+  O as addPortalGroup,
+  ne as addVirtualBoundary,
+  T as addZone,
+  Eo as applyMutation,
+  go as applyMutations,
+  Ie as barrierEnds,
+  pe as bindSpaceToRegion,
+  eo as blobDataUrl,
+  de as boundaryEdges,
+  ce as boundaryRegionAt,
+  fe as boundaryRegions,
+  me as boundaryRings,
+  Qo as buildRoomNavigation,
+  A as captive,
+  Ne as centroid,
+  To as chainVertical,
+  je as closeRing,
+  le as connectSpace,
+  Te as copyProject,
+  he as coverageOf,
+  te as createObject,
+  U as derivedGraph,
+  Ee as derivedSpaceRings,
+  ir as detectLayers,
+  ge as disconnectSpace,
+  Me as distance,
+  F as divideSpaces,
+  pr as documentSvg,
+  Re as drawVirtualBoundary,
+  Ve as duplicateFloor,
+  Ao as edgeCost,
+  _o as edgeLength,
+  X as effectivePortals,
+  ae as emptyProject,
+  R as enclosedRegion,
+  u as enclosedRegions,
+  _ as entryInto,
+  oo as exportProject,
+  Lo as findRoute,
+  Go as flights,
+  wo as flightsAt,
+  bo as floorPhrase,
+  ue as followsBoundaries,
+  De as footprint,
+  so as freezeProject,
+  Fe as geoOrigin,
+  er as importPlanEntities,
+  ro as importProject,
+  x as inSpace,
+  C as inferOpenBoundaries,
+  G as inferPortals,
+  q as isArea,
+  Q as isDevice,
+  $ as isOpening,
+  ee as isSpace,
+  Ko as isVertical,
+  cr as landmarks,
+  sr as layerPattern,
+  w as mergeSpaces,
+  Ce as moveOrigin,
+  Bo as navEdges,
+  Io as navNodes,
+  No as navPath,
+  L as nestZone,
+  d as neutralBasemap,
+  xe as normalizeBoundaries,
+  Ge as objectArea,
+  we as objectPosition,
+  Ke as objectRotation,
+  Ze as openRing,
+  Ae as openingFloorId,
+  to as parseExport,
+  Zo as passesThrough,
+  b as perimeter,
+  zo as pitchOf,
+  ze as pointInRing,
+  Ho as primaryShafts,
+  B as pruneOntology,
+  Uo as reaches,
+  He as rectangle,
+  P as refitEnclosedRooms,
+  Pe as refreshBoundarySpaces,
+  K as refreshPortals,
+  Ue as removeFloor,
+  I as removePortalGroup,
+  N as removeZone,
+  ke as ringArea,
+  Xe as rotate,
+  jo as routeAnchors,
+  Mo as routeSteps,
+  ko as runFor,
+  Ye as segmentProjection,
+  Je as segmentsCross,
+  Xo as servedFloors,
+  j as setPortalGroupMembers,
+  M as setZoneMembers,
+  Yo as shaftKey,
+  Jo as shaftVoids,
+  Y as sharedBoundaryPortals,
+  fr as sheetOffset,
+  mr as shiftEntities,
+  We as slopeElevation,
+  v as spaceAt,
+  S as spacePoint,
+  y as spaces,
+  Z as spacesDividedBy,
+  z as spacesRejoinedBy,
+  Wo as span,
+  qe as toLngLat,
+  Qe as toLocal,
+  no as transact,
+  oe as uid,
+  m as useDarkMode,
+  l as useKerrosTheme,
+  E as useStrings,
+  po as validateNavigation,
+  co as validateProject,
+  fo as validateRelationships,
+  mo as validateRings,
+  V as zoneSpaces
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/map/CabinMaterials.js

@@ -0,0 +1,81 @@
+var S = Object.defineProperty;
+var y = (r, e, s) => e in r ? S(r, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : r[e] = s;
+var a = (r, e, s) => y(r, typeof e != "symbol" ? e + "" : e, s);
+import * as t from "three";
+class C {
+  constructor(e) {
+    a(this, "steel");
+    a(this, "trim");
+    a(this, "wall");
+    a(this, "floor");
+    a(this, "dark");
+    a(this, "lamp", new t.MeshBasicMaterial({ color: "#fff0d5", toneMapped: !1 }));
+    a(this, "display", new t.MeshBasicMaterial({ color: "#f5c985", toneMapped: !1 }));
+    a(this, "environment");
+    a(this, "target");
+    a(this, "textures", []);
+    a(this, "owned", []);
+    const s = document.createElement("canvas");
+    s.width = 512, s.height = 256;
+    const o = s.getContext("2d"), l = o.createLinearGradient(0, 0, 0, 256);
+    l.addColorStop(0, "#faf1dd"), l.addColorStop(0.24, "#d6cec2"), l.addColorStop(0.55, "#aaa49d"), l.addColorStop(1, "#55585a"), o.fillStyle = l, o.fillRect(0, 0, 512, 256);
+    for (const n of [35, 150, 305, 440])
+      o.fillStyle = "#fffaf0", o.fillRect(n, 12, 28, 65), o.fillStyle = "#ddd5c6", o.fillRect(n + 10, 90, 5, 80);
+    const c = new t.CanvasTexture(s);
+    c.mapping = t.EquirectangularReflectionMapping, c.colorSpace = t.SRGBColorSpace;
+    const M = new t.PMREMGenerator(e);
+    this.target = M.fromEquirectangular(c), this.environment = this.target.texture, c.dispose(), M.dispose(), e.resetState();
+    const d = document.createElement("canvas");
+    d.width = 256, d.height = 512;
+    const m = d.getContext("2d"), u = m.createImageData(256, 512);
+    let p = 821;
+    const g = () => (p = Math.imul(p, 1664525) + 1013904223 | 0, (p >>> 0) / 4294967295), v = Array.from({ length: 256 }, () => g());
+    for (let n = 0; n < 512; n++)
+      for (let h = 0; h < 256; h++) {
+        const f = 190 + v[h] * 35 + g() * 6, w = (n * 256 + h) * 4;
+        u.data.set([f, f, f, 255], w);
+      }
+    m.putImageData(u, 0, 0);
+    const i = new t.CanvasTexture(d);
+    i.wrapS = i.wrapT = t.RepeatWrapping, i.repeat.set(2, 1), i.colorSpace = t.SRGBColorSpace, this.textures.push(i), this.steel = new t.MeshPhysicalMaterial({
+      color: "#c2c7cc",
+      map: i,
+      roughness: 0.3,
+      metalness: 0.92,
+      anisotropy: 0.65,
+      anisotropyRotation: Math.PI / 2,
+      envMap: this.environment,
+      envMapIntensity: 1.35
+    }), this.steel.userData.cabinSteel = !0, this.trim = new t.MeshStandardMaterial({
+      color: "#cbd0d3",
+      metalness: 0.95,
+      roughness: 0.18,
+      envMap: this.environment,
+      envMapIntensity: 1.4
+    }), this.wall = new t.MeshStandardMaterial({
+      color: "#b4a89a",
+      metalness: 0.05,
+      roughness: 0.65,
+      envMap: this.environment,
+      envMapIntensity: 1
+    }), this.floor = new t.MeshStandardMaterial({
+      color: "#6f7370",
+      roughness: 0.83,
+      envMap: this.environment,
+      envMapIntensity: 1.3
+    }), this.dark = new t.MeshStandardMaterial({
+      color: "#17232c",
+      roughness: 0.6,
+      envMap: this.environment,
+      envMapIntensity: 0.8
+    }), this.owned = [this.steel, this.trim, this.wall, this.floor, this.dark, this.lamp, this.display];
+    for (const n of this.owned) n.userData.shared = !0;
+  }
+  dispose() {
+    this.owned.forEach((e) => e.dispose()), this.textures.forEach((e) => e.dispose()), this.target.dispose();
+  }
+}
+export {
+  C as CabinMaterials
+};
+//# sourceMappingURL=CabinMaterials.js.map

package/dist/map/CabinMaterials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CabinMaterials.js","sources":["../../../../src/map/CabinMaterials.ts"],"sourcesContent":["import * as THREE from 'three';\n\n/** Private cabin finishes: their lighting environment is the ceiling diffuser, even in a dark\n * basement. Metals reflect this environment; the cabin walls do not glow like the old grey box. */\nexport class CabinMaterials {\n  readonly steel: THREE.MeshPhysicalMaterial;\n  readonly trim: THREE.MeshStandardMaterial;\n  readonly wall: THREE.MeshStandardMaterial;\n  readonly floor: THREE.MeshStandardMaterial;\n  readonly dark: THREE.MeshStandardMaterial;\n  readonly lamp = new THREE.MeshBasicMaterial({ color: '#fff0d5', toneMapped: false });\n  readonly display = new THREE.MeshBasicMaterial({ color: '#f5c985', toneMapped: false });\n  readonly environment: THREE.Texture;\n  private target: THREE.WebGLRenderTarget;\n  private textures: THREE.Texture[] = [];\n  private owned: THREE.Material[] = [];\n  constructor(renderer: THREE.WebGLRenderer) {\n    const canvas = document.createElement('canvas');\n    canvas.width = 512;\n    canvas.height = 256;\n    const ctx = canvas.getContext('2d')!;\n    const gradient = ctx.createLinearGradient(0, 0, 0, 256);\n    gradient.addColorStop(0, '#faf1dd');\n    gradient.addColorStop(0.24, '#d6cec2');\n    gradient.addColorStop(0.55, '#aaa49d');\n    gradient.addColorStop(1, '#55585a');\n    ctx.fillStyle = gradient;\n    ctx.fillRect(0, 0, 512, 256);\n    for (const x of [35, 150, 305, 440]) {\n      ctx.fillStyle = '#fffaf0';\n      ctx.fillRect(x, 12, 28, 65);\n      ctx.fillStyle = '#ddd5c6';\n      ctx.fillRect(x + 10, 90, 5, 80);\n    }\n    const environment = new THREE.CanvasTexture(canvas);\n    environment.mapping = THREE.EquirectangularReflectionMapping;\n    environment.colorSpace = THREE.SRGBColorSpace;\n    const generator = new THREE.PMREMGenerator(renderer);\n    this.target = generator.fromEquirectangular(environment);\n    this.environment = this.target.texture;\n    environment.dispose();\n    generator.dispose();\n    renderer.resetState();\n    const grain = document.createElement('canvas');\n    grain.width = 256;\n    grain.height = 512;\n    const g = grain.getContext('2d')!,\n      pixels = g.createImageData(256, 512);\n    let seed = 821;\n    const random = () => {\n      seed = (Math.imul(seed, 1664525) + 1013904223) | 0;\n      return (seed >>> 0) / 0xffffffff;\n    };\n    const stripes = Array.from({ length: 256 }, () => random());\n    for (let y = 0; y < 512; y++)\n      for (let x = 0; x < 256; x++) {\n        const value = 190 + stripes[x] * 35 + random() * 6;\n        const i = (y * 256 + x) * 4;\n        pixels.data.set([value, value, value, 255], i);\n      }\n    g.putImageData(pixels, 0, 0);\n    const brushed = new THREE.CanvasTexture(grain);\n    brushed.wrapS = brushed.wrapT = THREE.RepeatWrapping;\n    brushed.repeat.set(2, 1);\n    brushed.colorSpace = THREE.SRGBColorSpace;\n    this.textures.push(brushed);\n    this.steel = new THREE.MeshPhysicalMaterial({\n      color: '#c2c7cc',\n      map: brushed,\n      roughness: 0.3,\n      metalness: 0.92,\n      anisotropy: 0.65,\n      anisotropyRotation: Math.PI / 2,\n      envMap: this.environment,\n      envMapIntensity: 1.35,\n    });\n    this.steel.userData.cabinSteel = true;\n    this.trim = new THREE.MeshStandardMaterial({\n      color: '#cbd0d3',\n      metalness: 0.95,\n      roughness: 0.18,\n      envMap: this.environment,\n      envMapIntensity: 1.4,\n    });\n    this.wall = new THREE.MeshStandardMaterial({\n      color: '#b4a89a',\n      metalness: 0.05,\n      roughness: 0.65,\n      envMap: this.environment,\n      envMapIntensity: 1.0,\n    });\n    this.floor = new THREE.MeshStandardMaterial({\n      color: '#6f7370',\n      roughness: 0.83,\n      envMap: this.environment,\n      envMapIntensity: 1.3,\n    });\n    this.dark = new THREE.MeshStandardMaterial({\n      color: '#17232c',\n      roughness: 0.6,\n      envMap: this.environment,\n      envMapIntensity: 0.8,\n    });\n    this.owned = [this.steel, this.trim, this.wall, this.floor, this.dark, this.lamp, this.display];\n    for (const m of this.owned) m.userData.shared = true;\n  }\n  dispose() {\n    this.owned.forEach(m => m.dispose());\n    this.textures.forEach(t => t.dispose());\n    this.target.dispose();\n  }\n}\n"],"names":["CabinMaterials","renderer","__publicField","THREE","canvas","ctx","gradient","x","environment","generator","grain","g","pixels","seed","random","stripes","y","value","i","brushed","m","t"],"mappings":"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"}