@kensnzk/koyu 0.22.0 → 0.24.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (74) hide show
  1. package/dist/cli.js +51 -2
  2. package/dist/cli.js.map +1 -1
  3. package/dist/core/bodies.d.ts +26 -0
  4. package/dist/core/bodies.d.ts.map +1 -0
  5. package/dist/core/bodies.js +67 -0
  6. package/dist/core/bodies.js.map +1 -0
  7. package/dist/core/model.d.ts +20 -1
  8. package/dist/core/model.d.ts.map +1 -1
  9. package/dist/core/model.js +27 -1
  10. package/dist/core/model.js.map +1 -1
  11. package/dist/core/parse.d.ts.map +1 -1
  12. package/dist/core/parse.js +11 -13
  13. package/dist/core/parse.js.map +1 -1
  14. package/dist/core/poly.d.ts +35 -0
  15. package/dist/core/poly.d.ts.map +1 -1
  16. package/dist/core/poly.js +67 -0
  17. package/dist/core/poly.js.map +1 -1
  18. package/dist/core/section.d.ts +88 -0
  19. package/dist/core/section.d.ts.map +1 -0
  20. package/dist/core/section.js +247 -0
  21. package/dist/core/section.js.map +1 -0
  22. package/dist/draw/axo.d.ts.map +1 -1
  23. package/dist/draw/axo.js +13 -31
  24. package/dist/draw/axo.js.map +1 -1
  25. package/dist/draw/index.d.ts +4 -0
  26. package/dist/draw/index.d.ts.map +1 -1
  27. package/dist/draw/index.js +4 -0
  28. package/dist/draw/index.js.map +1 -1
  29. package/dist/draw/marks.d.ts +126 -0
  30. package/dist/draw/marks.d.ts.map +1 -0
  31. package/dist/draw/marks.js +227 -0
  32. package/dist/draw/marks.js.map +1 -0
  33. package/dist/draw/plan.d.ts.map +1 -1
  34. package/dist/draw/plan.js +117 -133
  35. package/dist/draw/plan.js.map +1 -1
  36. package/dist/draw/scene.d.ts +133 -0
  37. package/dist/draw/scene.d.ts.map +1 -0
  38. package/dist/draw/scene.js +251 -0
  39. package/dist/draw/scene.js.map +1 -0
  40. package/dist/draw/section.d.ts +23 -0
  41. package/dist/draw/section.d.ts.map +1 -0
  42. package/dist/draw/section.js +168 -0
  43. package/dist/draw/section.js.map +1 -0
  44. package/dist/draw/sheet.d.ts +40 -0
  45. package/dist/draw/sheet.d.ts.map +1 -0
  46. package/dist/draw/sheet.js +93 -0
  47. package/dist/draw/sheet.js.map +1 -0
  48. package/dist/draw/written.d.ts +27 -0
  49. package/dist/draw/written.d.ts.map +1 -0
  50. package/dist/draw/written.js +50 -0
  51. package/dist/draw/written.js.map +1 -0
  52. package/dist/form.d.ts +1 -0
  53. package/dist/form.d.ts.map +1 -1
  54. package/dist/form.js +4 -0
  55. package/dist/form.js.map +1 -1
  56. package/dist/mcp.js +67 -3
  57. package/dist/mcp.js.map +1 -1
  58. package/package.json +2 -2
  59. package/src/cli.ts +57 -1
  60. package/src/core/bodies.ts +90 -0
  61. package/src/core/model.ts +32 -1
  62. package/src/core/parse.ts +13 -12
  63. package/src/core/poly.ts +76 -0
  64. package/src/core/section.ts +311 -0
  65. package/src/draw/axo.ts +13 -29
  66. package/src/draw/index.ts +24 -0
  67. package/src/draw/marks.ts +315 -0
  68. package/src/draw/plan.ts +111 -130
  69. package/src/draw/scene.ts +389 -0
  70. package/src/draw/section.ts +224 -0
  71. package/src/draw/sheet.ts +102 -0
  72. package/src/draw/written.ts +64 -0
  73. package/src/form.ts +18 -0
  74. package/src/mcp.ts +75 -2
@@ -0,0 +1,311 @@
1
+ // koyu — the section and the elevation (ADR-0064)
2
+ //
3
+ // **This reads a `Form` and nothing else.** Every body it cuts was raised by `derive` and
4
+ // enumerated by `formBodies` (bodies.ts). It composes no matter; it re-frames what came out of the
5
+ // one entry point to shape, which is what `planOf` does for a horizontal plane and this does for a
6
+ // vertical one.
7
+ //
8
+ // **Why it is here and not in `src/draw/`.** Everything a section needs is public on `Form`, so a
9
+ // renderer could compute one without tripping a single import gate. What forbids it is not a test
10
+ // but docs/why/plan-is-not-a-section.md: "this is a section, this is a projection" is decided by
11
+ // comparing a range against a plane, and left to the drawing side the thresholds differ per
12
+ // implementation, so one source yields two drawings. The comparison here is the same one, turned
13
+ // on its side.
14
+ //
15
+ // **What a vertical plane needs that a slice does not give.** A slice hands back flat pieces at
16
+ // one x and an empty background. A section is mostly what stands *behind* the plane — the far wall
17
+ // with its windows, the stair beyond the cut — and none of that falls out of cutting. Nor does the
18
+ // decision to throw the near half away, which is a choice of viewpoint and has to be an input.
19
+
20
+ import { formBodies, type FormBody } from "./bodies.js";
21
+ import type { Form } from "./derive.js";
22
+ import type { Edge, Pt } from "./model.js";
23
+ import { crossing, hull, signedArea } from "./poly.js";
24
+ import { EPS } from "./tolerance.js";
25
+
26
+ /** Which axis names the plane. `"X"` means the plane `x = at`. */
27
+ export type SectionAxis = "X" | "Y";
28
+
29
+ /**
30
+ * What a vertical plane divides the mass into. **Two, where a plan has five.**
31
+ *
32
+ * A plan is looked at from above, so it carries what is below the cut, what is above it dropped
33
+ * back down, and the symbols of movement. A section is looked at from the side: what the plane
34
+ * crossed, and what stands behind it. What stands in front is not hidden by convention — it is
35
+ * behind the viewer — so it is not produced at all, and saying so here is what stops each
36
+ * consumer deciding it.
37
+ */
38
+ export type SectionClass = "cut" | "beyond";
39
+
40
+ export type SectionSubject = "space" | "boundary" | "opening" | "column" | "slab" | "run";
41
+
42
+ /** A point on the section. **Not a plan coordinate** — `u` runs across the sheet, `z` is height. */
43
+ export interface SectionPt {
44
+ u: number;
45
+ z: number;
46
+ }
47
+
48
+ /** The plane, and the direction it is looked at from. */
49
+ export interface SectionSpec {
50
+ axis: SectionAxis;
51
+ /** where the plane sits along `axis`, world mm */
52
+ at: number;
53
+ /** the grid reference it was named by, when it was named by one */
54
+ atRef?: string;
55
+ /** the direction of view. `W`/`E` across an X plane, `N`/`S` across a Y plane */
56
+ look: Edge;
57
+ }
58
+
59
+ export interface SectionEntity {
60
+ class: SectionClass;
61
+ of: SectionSubject;
62
+ /** identity of the subject, in the spelling the rest of `Form` uses */
63
+ ref: string;
64
+ /** what the subject already says it is — a slab's face, an opening's leaf, a run's device */
65
+ kind?: string;
66
+ /** counter-clockwise in (u, z), like every outline `Form` returns */
67
+ polygon: SectionPt[];
68
+ /**
69
+ * How far behind the plane the nearest point of the body stands, mm. `0` for anything the plane
70
+ * crossed. **It is a distance, not a draw order** — `Form` holds no draw order, and whether to
71
+ * sort by this, fade by it or ignore it is the drawing's business.
72
+ */
73
+ depth: number;
74
+ }
75
+
76
+ export interface FormSection {
77
+ axis: SectionAxis;
78
+ at: number;
79
+ atRef?: string;
80
+ look: Edge;
81
+ entities: SectionEntity[];
82
+ }
83
+
84
+ /** The direction of view as a unit vector in plan. */
85
+ function look(edge: Edge): Pt {
86
+ return edge === "N"
87
+ ? { x: 0, y: 1 }
88
+ : edge === "S"
89
+ ? { x: 0, y: -1 }
90
+ : edge === "E"
91
+ ? { x: 1, y: 0 }
92
+ : { x: -1, y: 0 };
93
+ }
94
+
95
+ /**
96
+ * The axis a direction of view crosses. Looking east or west crosses an X plane.
97
+ *
98
+ * A `look` that runs along the plane rather than across it draws nothing, so it is refused rather
99
+ * than answered — the same treatment `svgPlan` gives a level that was never declared.
100
+ */
101
+ export function axisOf(edge: Edge): SectionAxis {
102
+ return edge === "E" || edge === "W" ? "X" : "Y";
103
+ }
104
+
105
+ /**
106
+ * The direction a section is looked at from when nobody said.
107
+ *
108
+ * The rule is statable rather than conventional: **on the default, `u` is the world coordinate
109
+ * along the cut line**, so a dimension taken off the plan carries into the section without being
110
+ * reversed. Looking the other way mirrors the sheet, which is why it has to be asked for.
111
+ */
112
+ export function defaultLook(axis: SectionAxis): Edge {
113
+ return axis === "X" ? "W" : "N";
114
+ }
115
+
116
+ /**
117
+ * Where the sheet's `u` axis points, in plan. **It is the viewer's right hand**: `u = d × ẑ`.
118
+ *
119
+ * Facing north, east is on your right; facing east, south is. Fixing it here is what makes one
120
+ * spec give one drawing — a renderer that guessed would mirror the building and no test would
121
+ * catch it.
122
+ */
123
+ function rightOf(d: Pt): Pt {
124
+ return { x: d.y, y: -d.x };
125
+ }
126
+
127
+ /**
128
+ * The bodies a vertical plane may cut. **Outside and semi-outdoor spaces are dropped.** A storey's
129
+ * ceiling height reaches them, so they carry a z range, but no ceiling is derived over them
130
+ * (fabric.ts excludes both) and there is nothing above them to bound the air. Cutting one paints a
131
+ * garden as a room. A 3D scene keeps them, which is why the enumeration itself does not judge.
132
+ */
133
+ function cuttableBodies(form: Form): FormBody[] {
134
+ const airless = new Set(form.spaces.filter((s) => s.outside || s.semiOutdoor).map((s) => s.path));
135
+ return formBodies(form).filter((b) => !(b.of === "space" && airless.has(b.ref)));
136
+ }
137
+
138
+ /** The polygon a body leaves on the plane, or `undefined` where the plane only grazes a corner. */
139
+ function cutOf(body: FormBody, axis: SectionAxis, at: number, u: (p: Pt) => number): SectionPt[] | undefined {
140
+ const met = crossing(body.poly, axis, at);
141
+ if (!met) return undefined;
142
+ const n = body.poly.length;
143
+ // The height at a crossing, read off the edge it sits on. **This is exact, not sampled** — a
144
+ // per-vertex height means the height is linear along each edge, which is all the reading assumes.
145
+ const at01 = (v: number[], c: { edge: number; t: number }): number =>
146
+ v[c.edge]! + c.t * (v[(c.edge + 1) % n]! - v[c.edge]!);
147
+ const ends = met.map((c) => ({
148
+ u: u(body.poly[c.edge]!) + c.t * (u(body.poly[(c.edge + 1) % n]!) - u(body.poly[c.edge]!)),
149
+ z0: at01(body.bottom, c),
150
+ z1: at01(body.top, c),
151
+ }));
152
+ const [a, b] = ends[0]!.u <= ends[1]!.u ? [ends[0]!, ends[1]!] : [ends[1]!, ends[0]!];
153
+ if (b.u - a.u <= EPS) return undefined;
154
+ // Bottom-left, bottom-right, top-right, top-left — counter-clockwise with z up.
155
+ return [
156
+ { u: a.u, z: a.z0 },
157
+ { u: b.u, z: b.z0 },
158
+ { u: b.u, z: b.z1 },
159
+ { u: a.u, z: a.z1 },
160
+ ];
161
+ }
162
+
163
+ /**
164
+ * The shape a body throws onto the plane, seen head-on.
165
+ *
166
+ * A body of the `Form` is a prism over a convex ring whose top and bottom vary linearly, so it is
167
+ * a convex solid and **its shadow is the hull of its projected vertices** — exact, not an outline
168
+ * fitted to it. Where the top and bottom do not vary (everything but a ramp or an escalator) that
169
+ * hull is a rectangle, and it is taken directly.
170
+ */
171
+ function shadowOf(body: FormBody, u: (p: Pt) => number): SectionPt[] | undefined {
172
+ let uLo = Infinity;
173
+ let uHi = -Infinity;
174
+ let zLo = Infinity;
175
+ let zHi = -Infinity;
176
+ let level = true;
177
+ for (let i = 0; i < body.poly.length; i++) {
178
+ const v = u(body.poly[i]!);
179
+ if (v < uLo) uLo = v;
180
+ if (v > uHi) uHi = v;
181
+ const b = body.bottom[i]!;
182
+ const t = body.top[i]!;
183
+ if (b < zLo) zLo = b;
184
+ if (t > zHi) zHi = t;
185
+ if (b !== body.bottom[0] || t !== body.top[0]) level = false;
186
+ }
187
+ if (uHi - uLo <= EPS || zHi - zLo <= EPS) return undefined;
188
+ if (level) {
189
+ return [
190
+ { u: uLo, z: zLo },
191
+ { u: uHi, z: zLo },
192
+ { u: uHi, z: zHi },
193
+ { u: uLo, z: zHi },
194
+ ];
195
+ }
196
+ const pts: Pt[] = [];
197
+ for (let i = 0; i < body.poly.length; i++) {
198
+ const v = u(body.poly[i]!);
199
+ pts.push({ x: v, y: body.bottom[i]! }, { x: v, y: body.top[i]! });
200
+ }
201
+ const ring = hull(pts);
202
+ return ring.length >= 3 ? ring.map((p) => ({ u: p.x, z: p.y })) : undefined;
203
+ }
204
+
205
+ function entitiesOf(bodies: FormBody[], spec: SectionSpec): SectionEntity[] {
206
+ const d = look(spec.look);
207
+ const r = rightOf(d);
208
+ const u = (p: Pt): number => p.x * r.x + p.y * r.y;
209
+ /** How far behind the plane a point stands. Positive is away from the viewer. */
210
+ const behind = (p: Pt): number => (spec.axis === "X" ? (p.x - spec.at) * d.x : (p.y - spec.at) * d.y);
211
+
212
+ const out: SectionEntity[] = [];
213
+ for (const body of bodies) {
214
+ let lo = Infinity;
215
+ let hi = -Infinity;
216
+ for (const p of body.poly) {
217
+ const f = behind(p);
218
+ if (f < lo) lo = f;
219
+ if (f > hi) hi = f;
220
+ }
221
+ // **The body is asked which side it is wholly on, not how far it reaches past the plane.**
222
+ // Asking the second question needs the body to extend more than the tolerance on both sides,
223
+ // which a body no wider than the tolerance itself can never do — a `t:1` wall standing on the
224
+ // plane reaches −0.5 and +0.5, and would be reported as standing behind a plane that goes
225
+ // straight through it.
226
+ const wholly = { behind: lo >= -EPS && hi > EPS, front: hi <= EPS && lo < -EPS };
227
+ if (!wholly.behind && !wholly.front) {
228
+ // It reaches both sides: the plane crossed it.
229
+ const polygon = cutOf(body, spec.axis, spec.at, u);
230
+ if (polygon) {
231
+ out.push({ class: "cut", of: body.of, ref: body.ref, ...(body.kind ? { kind: body.kind } : {}), polygon, depth: 0 });
232
+ }
233
+ continue;
234
+ }
235
+ // Wholly at or behind the plane. A space is a void — from outside there is nothing to see.
236
+ if (wholly.behind && body.of !== "space") {
237
+ const polygon = shadowOf(body, u);
238
+ if (polygon) {
239
+ out.push({
240
+ class: "beyond",
241
+ of: body.of,
242
+ ref: body.ref,
243
+ ...(body.kind ? { kind: body.kind } : {}),
244
+ polygon,
245
+ // A face within the tolerance of the plane counts as on it, so the nearest point can
246
+ // measure a hair negative. `depth` is a distance behind the plane and never less than 0.
247
+ depth: Math.max(0, lo),
248
+ });
249
+ }
250
+ }
251
+ // Otherwise it stands in front of the plane, behind the viewer, and is not produced.
252
+ }
253
+ return out;
254
+ }
255
+
256
+ /**
257
+ * The section a vertical plane makes of a `Form`.
258
+ *
259
+ * The plane is named by an axis and a coordinate; `look` says which way it is faced, and must
260
+ * cross the plane rather than run along it.
261
+ */
262
+ export function sectionForm(form: Form, spec: SectionSpec): FormSection {
263
+ if (axisOf(spec.look) !== spec.axis) {
264
+ throw new Error(
265
+ `Looking ${spec.look} runs along the ${spec.axis} plane rather than across it (an X plane is looked at from E or W, a Y plane from N or S)`,
266
+ );
267
+ }
268
+ return {
269
+ axis: spec.axis,
270
+ at: spec.at,
271
+ ...(spec.atRef !== undefined ? { atRef: spec.atRef } : {}),
272
+ look: spec.look,
273
+ entities: entitiesOf(cuttableBodies(form), spec),
274
+ };
275
+ }
276
+
277
+ /**
278
+ * The elevation of one face — **a section whose plane misses the mass.**
279
+ *
280
+ * `face` names the side the viewer stands on: `S` is the south elevation, seen from the south.
281
+ * The plane is put at the extreme of the mass along the line of sight, so **nothing can straddle
282
+ * it and `cut` comes back empty by construction** rather than by a branch in the code. Where
283
+ * exactly it goes is free: the projection is orthographic, so moving the plane further back
284
+ * changes no `u` and no `z`, only the datum that `depth` is counted from.
285
+ */
286
+ export function elevationForm(form: Form, face: Edge): FormSection {
287
+ // Standing to the south means looking north.
288
+ const from: Edge = face === "N" ? "S" : face === "S" ? "N" : face === "E" ? "W" : "E";
289
+ const axis = axisOf(from);
290
+ const d = look(from);
291
+ const bodies = cuttableBodies(form);
292
+ // The near extreme along the line of sight: looking towards the larger coordinate puts the plane
293
+ // at the smallest, and looking towards the smaller puts it at the largest.
294
+ const towardsLarger = (axis === "X" ? d.x : d.y) > 0;
295
+ let at = 0;
296
+ let seen = false;
297
+ for (const body of bodies) {
298
+ for (const p of body.poly) {
299
+ const c = axis === "X" ? p.x : p.y;
300
+ if (!seen || (towardsLarger ? c < at : c > at)) at = c;
301
+ seen = true;
302
+ }
303
+ }
304
+ const spec: SectionSpec = { axis, at, look: from };
305
+ return { axis, at, look: from, entities: entitiesOf(bodies, spec) };
306
+ }
307
+
308
+ /** The area of a section polygon, mm². Used by the tests that hold the cut against the Form. */
309
+ export function sectionArea(polygon: SectionPt[]): number {
310
+ return Math.abs(signedArea(polygon.map((p) => ({ x: p.u, y: p.z }))));
311
+ }
package/src/draw/axo.ts CHANGED
@@ -15,6 +15,7 @@
15
15
 
16
16
  import { columnRect, derive, runPrism } from "../core/derive.js";
17
17
  import { type Model, type Pt } from "../core/model.js";
18
+ import { esc, Extent, INK, openSheet, r2 } from "./sheet.js";
18
19
 
19
20
  export interface AxoOptions {
20
21
  /** 見る向き — 建物のどの隅から見下ろすか (既定 SE) */
@@ -39,8 +40,6 @@ interface Prism {
39
40
  depth: number;
40
41
  }
41
42
 
42
- const INK = "#1f1f1f";
43
- const PAPER = "#faf8f4";
44
43
  /** 地盤面を見せる版の下端・上端 mm — 導出値ではなく紙の側の約束 */
45
44
  const GROUND_Z0 = -400;
46
45
  const GROUND_Z1 = -100;
@@ -135,34 +134,23 @@ export function svgAxo(model: Model, opts: AxoOptions = {}): string {
135
134
 
136
135
  // ---- 投影して奥から描く (画家のアルゴリズム) ----
137
136
  prisms.sort((a, b) => a.depth - b.depth);
138
- // **外接範囲は畳んで取る。**Math.min(...pts) は引数の数がスタックの限界に当たる —
139
- // 開口で割られた壁は区間ごとに一片なので、大きな例では十万点を超える
140
- let minX = Infinity;
141
- let maxX = -Infinity;
142
- let minY = Infinity;
143
- let maxY = -Infinity;
144
- const see = (p: [number, number]): void => {
145
- if (p[0] < minX) minX = p[0];
146
- if (p[0] > maxX) maxX = p[0];
147
- if (p[1] < minY) minY = p[1];
148
- if (p[1] > maxY) maxY = p[1];
149
- };
137
+ // **外接範囲は畳んで取る** (Extent) — 引数を展開すると点の数がスタックの限界に当たる
138
+ const ext = new Extent();
150
139
  for (const pr of prisms) {
151
140
  for (let i = 0; i < pr.poly.length; i++) {
152
- see(proj(pr.poly[i]!, pr.top[i]!));
153
- see(proj(pr.poly[i]!, pr.bottom[i]!));
141
+ const t = proj(pr.poly[i]!, pr.top[i]!);
142
+ const b = proj(pr.poly[i]!, pr.bottom[i]!);
143
+ ext.see(t[0], t[1]);
144
+ ext.see(b[0], b[1]);
154
145
  }
155
146
  }
156
147
  const M = 40;
157
- const W = (maxX - minX) * scale + M * 2;
158
- const H = (maxY - minY) * scale + M * 2;
159
- const sx = (v: number) => (v - minX) * scale + M;
160
- const sy = (v: number) => (v - minY) * scale + M;
161
-
162
- const out: string[] = [
163
- `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" font-family="'Hiragino Sans','Noto Sans JP',sans-serif">`,
164
- `<rect width="${W}" height="${H}" fill="${PAPER}"/>`,
165
- ];
148
+ const W = (ext.max0 - ext.min0) * scale + M * 2;
149
+ const H = (ext.max1 - ext.min1) * scale + M * 2;
150
+ const sx = (v: number) => (v - ext.min0) * scale + M;
151
+ const sy = (v: number) => (v - ext.min1) * scale + M;
152
+
153
+ const out: string[] = openSheet(W, H);
166
154
  const face = (ring: Array<[number, number]>, fill: string, shade: number) => {
167
155
  const d = ring.map(([x, y], i) => `${i === 0 ? "M" : "L"} ${r2(sx(x))} ${r2(sy(y))}`).join(" ");
168
156
  return `<path d="${d} Z" fill="${tint(fill, shade)}" stroke="${INK}" stroke-width="0.35" stroke-opacity="0.5"/>`;
@@ -194,7 +182,6 @@ export function svgAxo(model: Model, opts: AxoOptions = {}): string {
194
182
  }
195
183
  out.push(
196
184
  `<text x="${M - 24}" y="${H - 12}" font-size="11" fill="${INK}">${esc(model.name ?? "Untitled")} — axonometric (from ${dir})</text>`,
197
- `<text x="${W - M + 24}" y="${H - 12}" text-anchor="end" font-size="8.5" fill="#a49b8a">koyu — generated from spaces (floors, roofs, walls, columns, vertical circulation)</text>`,
198
185
  "</svg>",
199
186
  );
200
187
  return out.join("\n") + "\n";
@@ -216,6 +203,3 @@ function tint(hex: string, k: number): string {
216
203
  const ch = [n >> 16, (n >> 8) & 255, n & 255].map((v) => Math.round(Math.min(255, v * k)));
217
204
  return `#${ch.map((v) => v.toString(16).padStart(2, "0")).join("")}`;
218
205
  }
219
-
220
- const r2 = (v: number): number => Math.round(v * 100) / 100;
221
- const esc = (s: string): string => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
package/src/draw/index.ts CHANGED
@@ -8,4 +8,28 @@
8
8
  // **凍る面と凍らない面を、import 一行で見分けられるようにするため**である。
9
9
 
10
10
  export { svgPlan, type PlanOptions } from "./plan.js";
11
+ export {
12
+ planMarks,
13
+ SLIDE_POCKET,
14
+ type Mark,
15
+ type MarkArc,
16
+ type MarkNote,
17
+ type MarkOptions,
18
+ type MarkRole,
19
+ type MarkSubject,
20
+ } from "./marks.js";
11
21
  export { svgAxo, type AxoOptions } from "./axo.js";
22
+ export {
23
+ sceneOf,
24
+ type Scene,
25
+ type SceneFacts,
26
+ type SceneLevel,
27
+ type SceneLine,
28
+ type SceneMark,
29
+ type SceneNode,
30
+ type ScenePrism,
31
+ type SceneRole,
32
+ type SceneSubject,
33
+ } from "./scene.js";
34
+ export { svgSection, svgElevation, type SectionOptions, type ElevationOptions } from "./section.js";
35
+ export { writtenOf, type Written } from "./written.js";