@kensnzk/koyu 0.11.0 → 0.13.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 (100) hide show
  1. package/README.ja.md +3 -3
  2. package/README.md +2 -2
  3. package/dist/axo.d.ts +16 -0
  4. package/dist/axo.d.ts.map +1 -0
  5. package/dist/axo.js +211 -0
  6. package/dist/axo.js.map +1 -0
  7. package/dist/check.d.ts +78 -3
  8. package/dist/check.d.ts.map +1 -1
  9. package/dist/check.js +578 -121
  10. package/dist/check.js.map +1 -1
  11. package/dist/cli.js +93 -2
  12. package/dist/cli.js.map +1 -1
  13. package/dist/diff.d.ts +15 -0
  14. package/dist/diff.d.ts.map +1 -1
  15. package/dist/diff.js +68 -7
  16. package/dist/diff.js.map +1 -1
  17. package/dist/fabric.d.ts +28 -0
  18. package/dist/fabric.d.ts.map +1 -0
  19. package/dist/fabric.js +105 -0
  20. package/dist/fabric.js.map +1 -0
  21. package/dist/graph.d.ts +40 -3
  22. package/dist/graph.d.ts.map +1 -1
  23. package/dist/graph.js +352 -53
  24. package/dist/graph.js.map +1 -1
  25. package/dist/index.d.ts +3 -0
  26. package/dist/index.d.ts.map +1 -1
  27. package/dist/index.js +3 -0
  28. package/dist/index.js.map +1 -1
  29. package/dist/light.d.ts.map +1 -1
  30. package/dist/light.js +4 -6
  31. package/dist/light.js.map +1 -1
  32. package/dist/mcp.js +16 -9
  33. package/dist/mcp.js.map +1 -1
  34. package/dist/model.d.ts +123 -8
  35. package/dist/model.d.ts.map +1 -1
  36. package/dist/model.js +171 -68
  37. package/dist/model.js.map +1 -1
  38. package/dist/parse.d.ts.map +1 -1
  39. package/dist/parse.js +123 -5
  40. package/dist/parse.js.map +1 -1
  41. package/dist/plan.d.ts +2 -0
  42. package/dist/plan.d.ts.map +1 -1
  43. package/dist/plan.js +97 -10
  44. package/dist/plan.js.map +1 -1
  45. package/dist/poly.d.ts +78 -0
  46. package/dist/poly.d.ts.map +1 -0
  47. package/dist/poly.js +277 -0
  48. package/dist/poly.js.map +1 -0
  49. package/dist/site.d.ts.map +1 -1
  50. package/dist/site.js +5 -4
  51. package/dist/site.js.map +1 -1
  52. package/dist/vertical.d.ts +176 -0
  53. package/dist/vertical.d.ts.map +1 -0
  54. package/dist/vertical.js +669 -0
  55. package/dist/vertical.js.map +1 -0
  56. package/examples/basement/main.muro +84 -0
  57. package/examples/comparison/README.md +48 -0
  58. package/examples/complex/L1.muro +132 -0
  59. package/examples/complex/assets.muro +17 -0
  60. package/examples/complex/basement.muro +40 -0
  61. package/examples/complex/core.muro +40 -0
  62. package/examples/complex/hotel.muro +117 -0
  63. package/examples/complex/main.muro +67 -0
  64. package/examples/complex/office.muro +41 -0
  65. package/examples/complex/plant.muro +34 -0
  66. package/examples/complex/podium.muro +140 -0
  67. package/examples/complex/site.muro +18 -0
  68. package/examples/house/L1.muro +1 -1
  69. package/examples/house/L2.muro +1 -1
  70. package/examples/house/main.muro +1 -1
  71. package/examples/house.muro +3 -3
  72. package/examples/mansion.muro +18 -13
  73. package/examples/office.muro +1 -1
  74. package/examples/steps/04-exterior.muro +1 -1
  75. package/examples/steps/05-two-storeys.muro +2 -2
  76. package/examples/steps/06-finished.muro +3 -3
  77. package/examples/tower/L11.muro +4 -2
  78. package/examples/tower/L2.muro +2 -0
  79. package/examples/tower/L3.muro +3 -0
  80. package/examples/tower/assets.muro +1 -0
  81. package/examples/tower/main.muro +1 -1
  82. package/examples/tower/typical.muro +16 -9
  83. package/examples/two-rooms.canonical.json +26 -2
  84. package/examples/two-rooms.muro +6 -3
  85. package/package.json +3 -2
  86. package/src/axo.ts +258 -0
  87. package/src/check.ts +680 -143
  88. package/src/cli.ts +100 -2
  89. package/src/diff.ts +75 -7
  90. package/src/fabric.ts +123 -0
  91. package/src/graph.ts +366 -56
  92. package/src/index.ts +24 -0
  93. package/src/light.ts +4 -7
  94. package/src/mcp.ts +17 -10
  95. package/src/model.ts +256 -66
  96. package/src/parse.ts +124 -5
  97. package/src/plan.ts +120 -11
  98. package/src/poly.ts +295 -0
  99. package/src/site.ts +6 -6
  100. package/src/vertical.ts +884 -0
@@ -0,0 +1,884 @@
1
+ // koyu — 縦動線の導出 (ADR-0021)
2
+ // 階段・斜路・エスカレーター・昇降機は「レベル間を通れる」という一つの関係の、
3
+ // 装置の違いにすぎない。トポロジー (どのレベルとどのレベルが繋がるか) は
4
+ // 垂直境界 (type:stair — graph.ts) が持ち、ここが答えるのは形である。
5
+ //
6
+ // 形はソースに無い。空間の領域と階高と「上る向き」の宣言だけから、
7
+ // 段割り・踊り場・勾配・立体・平面の切断をルールで生成する。
8
+ // 段数も踏面も勾配も書かれない — 書かないが検査する (RUN06 / RUN07)。
9
+
10
+ import { levelsSorted, type Edge, type Model, type Pt, type Rect, type Space } from "./model.js";
11
+
12
+ /** 装置。トポロジーではなく形の生成規則を選ぶ語 */
13
+ export type RunDevice = "stair" | "ramp" | "escalator" | "lift";
14
+ /** 宣言に使う属性キー = 装置名。値は上る向き (lift だけ 1) */
15
+ export const RUN_KEYS: readonly RunDevice[] = ["stair", "ramp", "escalator", "lift"];
16
+
17
+ /** 折返しの形式。曲線は導入しない — 螺旋は折返しの連続として書く (ADR-0021) */
18
+ export type RunForm = "straight" | "return";
19
+ export const RUN_FORMS: readonly RunForm[] = ["straight", "return"];
20
+
21
+ /** 既定の蹴上げ上限 mm (riser: で上書き) */
22
+ const DEFAULT_RISER_MAX = 180;
23
+ /** 踏面がこれを下回ると窮屈 (RUN06) */
24
+ const TREAD_MIN = 240;
25
+ /** 折返し階段の踊り場を導くときの目標踏面 mm (tread: で上書き) */
26
+ const TREAD_TARGET = 300;
27
+ /** 蹴上げ2倍+踏面 の快適域 (RUN06) */
28
+ const STEP_RULE = { lo: 550, hi: 700 };
29
+ /** エスカレーターの標準勾配 (30度 ≒ 1/1.73) と許容 */
30
+ const ESCALATOR_SLOPE = { lo: 1 / 2.3, hi: 1 / 1.4 };
31
+ /** 平面図の切断面 — FLからの高さ mm */
32
+ export const CUT_HEIGHT = 1200;
33
+ /** 踊り場の最小奥行 mm */
34
+ const LANDING_MIN = 1100;
35
+ /** 乗り込みの床の既定の奥行 mm (entry: で上書き) — 扉が段板に直接ぶつからないための帯 */
36
+ const ENTRY_LANDING = 1100;
37
+ /** エスカレーター一台の既定の呼び幅 mm (lane: で上書き) */
38
+ const LANE_ESCALATOR = 1200;
39
+ /** 平面のエスカレーターの段の刻みのピッチ mm */
40
+ const STEP_MARK = 400;
41
+ /** 段板の見付け厚 (立体) mm */
42
+ const TREAD_SOLID = 200;
43
+ /** 斜路・エスカレーター床版の厚さ mm */
44
+ const SLAB_T = 200;
45
+
46
+ /** 走りと踊り場の一区間。局所座標は t (走り方向) と s (進行方向の左からの幅) */
47
+ export interface RunPart {
48
+ kind: "flight" | "landing";
49
+ rect: Rect;
50
+ /** 走り方向の区間 mm (t0 < t1、宣言された向きの枠で測る) */
51
+ t0: number;
52
+ t1: number;
53
+ /** 幅方向の区間 mm */
54
+ s0: number;
55
+ s1: number;
56
+ /**
57
+ * t0 における高さ / t1 における高さ。**幾何はこの二つが全てである** —
58
+ * どちらへ傾くかも、段がどちらから上がるかも、ここから決まる
59
+ */
60
+ z0: number;
61
+ z1: number;
62
+ /**
63
+ * **人の進む向きが「t の減る向き」か。**幾何とは独立である (ADR-0021 追記)。
64
+ * 折返しの二本目は幾何も逆 (t0 側が高い) だが、並列の下りエスカレーターは
65
+ * 幾何は上りと同じで進む向きだけが逆である。この一語を幾何の意味でも読んだために、
66
+ * 下りの台が鏡像に傾き、DN矢印が上向きに描かれ、二台目が平面から消えていた。
67
+ */
68
+ reversed: boolean;
69
+ /** 蹴上げの数 (階段の走りのみ) */
70
+ risers?: number;
71
+ /** 踏面 mm (階段の走りのみ) */
72
+ tread?: number;
73
+ /** 並列の何台目か (エスカレーター) */
74
+ lane?: number;
75
+ }
76
+
77
+ export interface VerticalRun {
78
+ /** 宣言した空間のパス */
79
+ path: string;
80
+ device: RunDevice;
81
+ form: RunForm;
82
+ level: string;
83
+ /** 上の到達先レベル (無ければ undefined — lift は同レベルで閉じる) */
84
+ upper?: string;
85
+ z0: number;
86
+ z1: number;
87
+ /** 上がる高さ mm */
88
+ rise: number;
89
+ /** 上る向き (lift は N を入れるが意味を持たない) */
90
+ up: Edge;
91
+ /** 折返しの向き: R=踊り場で右へ回る (既定) */
92
+ turn: "L" | "R";
93
+ rect: Rect;
94
+ /** 走り方向の全長 mm */
95
+ length: number;
96
+ /** 幅 (走りと直交) mm */
97
+ width: number;
98
+ /** 乗り込みの床の奥行 mm (走りが領域の縁から始まらないための帯) */
99
+ entry: number;
100
+ /** 並列の台数 (エスカレーター。他は1) */
101
+ lanes: number;
102
+ parts: RunPart[];
103
+ /** 蹴上げの数 (階段のみ) */
104
+ risers: number;
105
+ /** 蹴上げ mm (階段のみ) */
106
+ riser: number;
107
+ /** 踏面 mm (階段のみ)。走りごとに違うときは**最も窮屈な走り**が代表する (RUN06) */
108
+ tread: number;
109
+ /** 最も急な走りの勾配 (rise/走り長)。1/N の N は 1/slope */
110
+ slope: number;
111
+ /** 走りの水平長の合計 mm (踊り場を含まない) */
112
+ going: number;
113
+ }
114
+
115
+ // ---- 宣言の読み取り ----
116
+
117
+ export interface RunDecl {
118
+ device: RunDevice;
119
+ /** 書かれた値 (未検証) */
120
+ value: string;
121
+ }
122
+
123
+ /** 空間に書かれた縦動線の宣言をすべて返す (複数は RUN01) */
124
+ export function runDecls(s: Space): RunDecl[] {
125
+ const out: RunDecl[] = [];
126
+ for (const k of RUN_KEYS) {
127
+ const v = s.attrs[k];
128
+ if (v !== undefined) out.push({ device: k, value: String(v) });
129
+ }
130
+ return out;
131
+ }
132
+
133
+ const EDGES = new Set<string>(["N", "E", "S", "W"]);
134
+ const OPPOSITE: Record<Edge, Edge> = { N: "S", S: "N", E: "W", W: "E" };
135
+
136
+ // ---- 局所座標 (t = 進む向き / s = 進行方向の左からの距離) ----
137
+
138
+ /**
139
+ * 走りの局所座標 (t,s) を世界の矩形へ写す。
140
+ * t は進む向きに 0 から、s は**進行方向の左**から測る (折返しの左右がここで決まる)
141
+ */
142
+ export function toWorld(rect: Rect, up: Edge, t0: number, t1: number, s0: number, s1: number): Rect {
143
+ switch (up) {
144
+ case "N":
145
+ return { x1: rect.x1 + s0, x2: rect.x1 + s1, y1: rect.y1 + t0, y2: rect.y1 + t1 };
146
+ case "S":
147
+ return { x1: rect.x2 - s1, x2: rect.x2 - s0, y1: rect.y2 - t1, y2: rect.y2 - t0 };
148
+ case "E":
149
+ return { x1: rect.x1 + t0, x2: rect.x1 + t1, y1: rect.y2 - s1, y2: rect.y2 - s0 };
150
+ case "W":
151
+ return { x1: rect.x2 - t1, x2: rect.x2 - t0, y1: rect.y1 + s0, y2: rect.y1 + s1 };
152
+ }
153
+ }
154
+
155
+ /** 走り方向の全長と幅 */
156
+ function extent(rect: Rect, up: Edge): { length: number; width: number } {
157
+ const dx = rect.x2 - rect.x1;
158
+ const dy = rect.y2 - rect.y1;
159
+ return up === "N" || up === "S" ? { length: dy, width: dx } : { length: dx, width: dy };
160
+ }
161
+
162
+ // ---- 導出 ----
163
+
164
+ /**
165
+ * モデル中の縦動線をすべて導く。
166
+ * 宣言が壊れている空間 (値が方位でない・領域が単一矩形でない・レベル不明) は
167
+ * ここでは黙って落とし、check が RUN01..RUN05 として言葉にする。
168
+ */
169
+ export function verticalRuns(model: Model): VerticalRun[] {
170
+ const levels = levelsSorted(model);
171
+ const out: VerticalRun[] = [];
172
+ for (const s of model.spaces.values()) {
173
+ const run = verticalRun(model, s, levels);
174
+ if (run) out.push(run);
175
+ }
176
+ return out.sort((a, b) => (a.z0 - b.z0) || (a.path < b.path ? -1 : 1));
177
+ }
178
+
179
+ /** 一つの空間の縦動線。宣言が無い/壊れているときは undefined */
180
+ export function verticalRun(
181
+ model: Model,
182
+ s: Space,
183
+ levels = levelsSorted(model),
184
+ ): VerticalRun | undefined {
185
+ const decls = runDecls(s);
186
+ if (decls.length !== 1) return undefined;
187
+ const { device, value } = decls[0]!;
188
+ if (s.rects.length !== 1 || !s.level) return undefined;
189
+ const rect = s.rects[0]!;
190
+ const li = levels.findIndex((l) => l.name === s.level);
191
+ if (li < 0) return undefined;
192
+
193
+ const up = device === "lift" ? "N" : (value as Edge);
194
+ if (device !== "lift" && !EDGES.has(value)) return undefined;
195
+ if (device === "lift" && value !== "1") return undefined;
196
+
197
+ const formRaw = String(s.attrs["form"] ?? "straight");
198
+ if (!RUN_FORMS.includes(formRaw as RunForm)) return undefined;
199
+ const form = formRaw as RunForm;
200
+ if (device !== "stair" && device !== "ramp" && form !== "straight") return undefined;
201
+
202
+ const z0 = levels[li]!.z;
203
+ const upper = levels[li + 1];
204
+ if (!upper && device !== "lift") return undefined; // 上る先が無い — RUN04
205
+ const z1 = upper?.z ?? z0;
206
+ const rise = z1 - z0;
207
+
208
+ const turn = s.attrs["turn"] === "L" ? "L" : "R";
209
+ const { length, width } = extent(rect, up);
210
+
211
+ const base = {
212
+ path: s.path,
213
+ device,
214
+ form,
215
+ level: s.level,
216
+ ...(upper ? { upper: upper.name } : {}),
217
+ z0,
218
+ z1,
219
+ rise,
220
+ up,
221
+ turn: turn as "L" | "R",
222
+ rect,
223
+ length,
224
+ width,
225
+ };
226
+ if (device === "lift") {
227
+ return { ...base, entry: 0, lanes: 1, parts: [], risers: 0, riser: 0, tread: 0, slope: 0, going: 0 };
228
+ }
229
+
230
+ // 乗り込みの床 (ADR-0021)。走りは領域の縁からは始まらない — 縁から始めると、
231
+ // 階段室の扉が段板に直接ぶつかる。近端 (と直階段では遠端) に階の床が残り、
232
+ // そこが扉の開く場所になる。この帯は走りではないので部品にはしない (階の床である)。
233
+ const entry = Math.max(0, numAttr(s, "entry") ?? ENTRY_LANDING);
234
+ const usable = form === "return" ? length - entry : length - entry * 2;
235
+ if (usable <= 0) return undefined; // 乗り込みが全長を食う — RUN05
236
+
237
+ // 並列の台数 (エスカレーター)。一台の呼び幅は lane: (既定1200mm)。
238
+ // 上りと下りが並ぶのが実機の姿なので、台ごとに走る向きが交互になる
239
+ const lane = Math.max(1, numAttr(s, "lane") ?? (device === "escalator" ? LANE_ESCALATOR : width));
240
+ const lanes = device === "escalator" ? Math.max(1, Math.floor(width / lane)) : 1;
241
+ const laneW = device === "escalator" ? Math.min(lane, width / lanes) : width;
242
+ const laneMargin = (width - laneW * lanes) / 2;
243
+
244
+ const parts: RunPart[] = [];
245
+ let risersTotal = 0;
246
+ let riser = 0;
247
+ let tread = 0;
248
+
249
+ if (form === "return") {
250
+ // 折返し: 幅を二分し、遠端に中間踊り場。turn:R なら第一の走りが進行方向の左
251
+ const mid = returnLanding(s, device, rise, length - entry, width);
252
+ const flightLen = length - entry - mid;
253
+ if (flightLen <= 0) return undefined; // RUN05
254
+ const half = width / 2;
255
+ const [aS, aE] = turn === "R" ? [0, half] : [half, width];
256
+ const [bS, bE] = turn === "R" ? [half, width] : [0, half];
257
+ const tA0 = entry;
258
+ const tA1 = entry + flightLen;
259
+
260
+ if (device === "stair") {
261
+ risersTotal = Math.max(2, Math.ceil(rise / (numAttr(s, "riser") ?? DEFAULT_RISER_MAX)));
262
+ riser = rise / risersTotal;
263
+ const k = Math.min(risersTotal - 1, Math.max(1, Math.round(risersTotal / 2)));
264
+ const zMid = z0 + k * riser;
265
+ tread = flightLen / Math.max(1, k - 1);
266
+ parts.push(
267
+ flight(rect, up, tA0, tA1, aS, aE, z0, zMid, false, k, flightLen / Math.max(1, k - 1)),
268
+ landingPart(rect, up, tA1, length, 0, width, zMid),
269
+ // 二本目は遠端から近端へ戻る — t が減る向きに走り、z は増える
270
+ flight(rect, up, tA0, tA1, bS, bE, z1, zMid, true, risersTotal - k, flightLen / Math.max(1, risersTotal - k - 1)),
271
+ );
272
+ } else {
273
+ const zMid = z0 + rise / 2;
274
+ parts.push(
275
+ flight(rect, up, tA0, tA1, aS, aE, z0, zMid, false),
276
+ landingPart(rect, up, tA1, length, 0, width, zMid),
277
+ flight(rect, up, tA0, tA1, bS, bE, z1, zMid, true),
278
+ );
279
+ }
280
+ } else {
281
+ const t0 = entry;
282
+ const t1 = length - entry;
283
+ if (device === "stair") {
284
+ risersTotal = Math.max(2, Math.ceil(rise / (numAttr(s, "riser") ?? DEFAULT_RISER_MAX)));
285
+ riser = rise / risersTotal;
286
+ tread = usable / Math.max(1, risersTotal - 1);
287
+ parts.push(flight(rect, up, t0, t1, 0, width, z0, z1, false, risersTotal, tread));
288
+ } else {
289
+ // 並列の台。台ごとに走る向きが交互 — 上りの隣は上から降りてくる一台である
290
+ for (let i = 0; i < lanes; i++) {
291
+ const s0 = laneMargin + i * laneW;
292
+ parts.push(flight(rect, up, t0, t1, s0, s0 + laneW, z0, z1, i % 2 === 1, undefined, undefined, i));
293
+ }
294
+ }
295
+ }
296
+
297
+ const going = parts
298
+ .filter((p) => p.kind === "flight" && (p.lane ?? 0) === 0)
299
+ .reduce((a, p) => a + (p.t1 - p.t0), 0);
300
+
301
+ // **踏面は走りごとに違う。**折返しの二本目は段数が多い分だけ細かいので、
302
+ // 一本目だけを見ると窮屈な走りが検査 (RUN06) をすり抜ける。最も窮屈な走りが代表する
303
+ const perFlight = parts.flatMap((p) => (p.kind === "flight" && p.tread ? [p.tread] : []));
304
+ if (perFlight.length > 0) tread = Math.min(...perFlight);
305
+
306
+ const slope = Math.max(
307
+ ...parts
308
+ .filter((p) => p.kind === "flight")
309
+ .map((p) => (p.t1 - p.t0 > 0 ? Math.abs(p.z1 - p.z0) / (p.t1 - p.t0) : 0)),
310
+ );
311
+
312
+ return { ...base, entry, lanes, parts, risers: risersTotal, riser, tread, slope, going };
313
+ }
314
+
315
+ /** 走りの部品。z0/z1 は t0/t1 における高さ (走る向きは reversed が言う) */
316
+ function flight(
317
+ rect: Rect,
318
+ up: Edge,
319
+ t0: number,
320
+ t1: number,
321
+ s0: number,
322
+ s1: number,
323
+ z0: number,
324
+ z1: number,
325
+ reversed: boolean,
326
+ risers?: number,
327
+ tread?: number,
328
+ lane?: number,
329
+ ): RunPart {
330
+ return {
331
+ kind: "flight",
332
+ rect: toWorld(rect, up, t0, t1, s0, s1),
333
+ t0,
334
+ t1,
335
+ s0,
336
+ s1,
337
+ z0,
338
+ z1,
339
+ reversed,
340
+ ...(risers !== undefined ? { risers } : {}),
341
+ ...(tread !== undefined ? { tread } : {}),
342
+ ...(lane !== undefined ? { lane } : {}),
343
+ };
344
+ }
345
+
346
+ function landingPart(
347
+ rect: Rect,
348
+ up: Edge,
349
+ t0: number,
350
+ t1: number,
351
+ s0: number,
352
+ s1: number,
353
+ z: number,
354
+ ): RunPart {
355
+ return {
356
+ kind: "landing",
357
+ rect: toWorld(rect, up, t0, t1, s0, s1),
358
+ t0,
359
+ t1,
360
+ s0,
361
+ s1,
362
+ z0: z,
363
+ z1: z,
364
+ reversed: false,
365
+ };
366
+ }
367
+
368
+ function numAttr(s: Space, key: string): number | undefined {
369
+ const v = s.attrs[key];
370
+ return typeof v === "number" ? v : undefined;
371
+ }
372
+
373
+ /**
374
+ * 折返しの中間踊り場の奥行 mm。`landing:` があればそれ、無ければ導く。
375
+ *
376
+ * 走り長・踏面・踊り場は一つの式で結ばれていて、書けるのは高々二つである。
377
+ * 領域 (平面が決める) と目標踏面 (快適さの定数) を与えると、踊り場は残余として決まる。
378
+ * 逆に踊り場を書けば踏面が残余になる — **設計者が握りたいのは踏面の快適さ**なので、
379
+ * 既定では残余を踊り場へ寄せる。踊り場が設計量になる場合は `landing:` で書き、
380
+ * その結果の踏面は RUN06 が検査する (ADR-0021)。
381
+ */
382
+ function returnLanding(
383
+ s: Space,
384
+ device: RunDevice,
385
+ rise: number,
386
+ length: number,
387
+ width: number,
388
+ ): number {
389
+ const written = numAttr(s, "landing");
390
+ if (written !== undefined) return Math.max(LANDING_MIN, written);
391
+ if (device !== "stair") {
392
+ // 斜路: 走りが長いほど勾配が緩い。踊り場は要る分だけ (幅の半分か最小値)
393
+ return Math.max(LANDING_MIN, Math.min(width / 2, length / 3));
394
+ }
395
+ const target = numAttr(s, "tread") ?? TREAD_TARGET;
396
+ const riserMax = numAttr(s, "riser") ?? DEFAULT_RISER_MAX;
397
+ const n = Math.max(2, Math.ceil(rise / riserMax));
398
+ const k = Math.min(n - 1, Math.max(1, Math.round(n / 2)));
399
+ const treads = Math.max(1, Math.max(k - 1, n - k - 1));
400
+ return Math.max(LANDING_MIN, Math.min(length - treads * target, length - LANDING_MIN));
401
+ }
402
+
403
+ /** 勾配の 1/N 表記 (N は小数第1位) */
404
+ export function slopeText(slope: number): string {
405
+ if (slope <= 0) return "—";
406
+ return `1/${(1 / slope).toFixed(1).replace(/\.0$/, "")}`;
407
+ }
408
+
409
+ // ---- 局所座標の点 ----
410
+
411
+ /** 走りの局所座標 (t,s) を世界の点へ (toWorld の点版 — 向きが保たれる) */
412
+ export function toPoint(rect: Rect, up: Edge, t: number, s: number): Pt {
413
+ switch (up) {
414
+ case "N":
415
+ return { x: rect.x1 + s, y: rect.y1 + t };
416
+ case "S":
417
+ return { x: rect.x2 - s, y: rect.y2 - t };
418
+ case "E":
419
+ return { x: rect.x1 + t, y: rect.y2 - s };
420
+ case "W":
421
+ return { x: rect.x2 - t, y: rect.y1 + s };
422
+ }
423
+ }
424
+
425
+ // ---- 立体 (ビルド) ----
426
+
427
+ /**
428
+ * 生成された立体 — 依存ゼロの素の記述。ビュアーはこれを幾何へ写すだけで、
429
+ * 段割りや勾配の判断は一切持たない (README の「ビュアーは答えを持たない」)
430
+ */
431
+ export type RunSolid =
432
+ /** 軸平行の直方体 — 段板・踊り場・エスカレーターの端部・かご */
433
+ | { kind: "box"; rect: Rect; z0: number; z1: number }
434
+ /** 傾いた版 — rect の up 側へ z0→z1 で上がる厚さ t の板 (斜路・トラス・欄干) */
435
+ | { kind: "incline"; rect: Rect; up: Edge; z0: number; z1: number; t: number };
436
+
437
+ /** 縦動線の三次元形状。段は段として、斜路は傾いた版として立ち上がる */
438
+ export function runSolids(run: VerticalRun): RunSolid[] {
439
+ const out: RunSolid[] = [];
440
+ if (run.device === "lift") {
441
+ const m = Math.min(300, (run.rect.x2 - run.rect.x1) / 6, (run.rect.y2 - run.rect.y1) / 6);
442
+ out.push({
443
+ kind: "box",
444
+ rect: { x1: run.rect.x1 + m, y1: run.rect.y1 + m, x2: run.rect.x2 - m, y2: run.rect.y2 - m },
445
+ z0: run.z0 + 60,
446
+ z1: run.z0 + 2400,
447
+ });
448
+ return out;
449
+ }
450
+
451
+ for (const p of run.parts) {
452
+ if (p.kind === "landing") {
453
+ out.push({ kind: "box", rect: p.rect, z0: p.z0 - SLAB_T, z1: p.z0 });
454
+ continue;
455
+ }
456
+ const len = p.t1 - p.t0;
457
+ // **傾きは z から決める。**reversed (人の進む向き) では決めない —
458
+ // 下りのエスカレーターは幾何としては上りと同じ向きに傾いている
459
+ const dir = p.z1 >= p.z0 ? run.up : OPPOSITE[run.up];
460
+ const zLow = Math.min(p.z0, p.z1);
461
+ const zHigh = Math.max(p.z0, p.z1);
462
+
463
+ if (run.device === "stair") {
464
+ const k = p.risers ?? 1;
465
+ const treads = Math.max(1, k - 1);
466
+ const d = len / treads;
467
+ const rise = (zHigh - zLow) / k;
468
+ for (let i = 1; i <= treads; i++) {
469
+ // 走る向きに i 段目。段板は蹴上げ+控えの厚みを持ち、隣と重なって連続した段形になる
470
+ const fromT1 = p.z0 > p.z1; // 高いのが t0 側なら、段は t1 から t0 へ上がる
471
+ const a = fromT1 ? p.t1 - i * d : p.t0 + (i - 1) * d;
472
+ const b = fromT1 ? p.t1 - (i - 1) * d : p.t0 + i * d;
473
+ const top = zLow + i * rise;
474
+ out.push({
475
+ kind: "box",
476
+ rect: toWorld(run.rect, run.up, Math.min(a, b), Math.max(a, b), p.s0, p.s1),
477
+ z0: top - rise - TREAD_SOLID,
478
+ z1: top,
479
+ });
480
+ }
481
+ continue;
482
+ }
483
+ // 斜路・エスカレーター: 傾いた版。dir 側へ上がる
484
+ out.push({ kind: "incline", rect: p.rect, up: dir, z0: zLow, z1: zHigh, t: SLAB_T });
485
+ if (run.device === "escalator") {
486
+ // 欄干 (両側の傾いた薄板) — 一台ごとに二枚。見た目がエスカレーターになる最小
487
+ const bal = Math.min(140, (p.s1 - p.s0) / 8);
488
+ for (const [q0, q1] of [
489
+ [p.s0, p.s0 + bal],
490
+ [p.s1 - bal, p.s1],
491
+ ] as const) {
492
+ out.push({
493
+ kind: "incline",
494
+ rect: toWorld(run.rect, run.up, p.t0, p.t1, q0, q1),
495
+ up: dir,
496
+ z0: zLow + 900,
497
+ z1: zHigh + 900,
498
+ t: 100,
499
+ });
500
+ }
501
+ }
502
+ }
503
+ return out;
504
+ }
505
+
506
+ // ---- 平面 (切断) ----
507
+
508
+ export interface Seg2 {
509
+ x1: number;
510
+ y1: number;
511
+ x2: number;
512
+ y2: number;
513
+ }
514
+
515
+ export interface RunArrow extends Seg2 {
516
+ label: string;
517
+ }
518
+
519
+ /** そのレベルで切った縦動線の作図。平面図とビュアーが共有する唯一の答え */
520
+ export interface RunDraw {
521
+ path: string;
522
+ device: RunDevice;
523
+ /** 段鼻 (階段) / 段の刻み (エスカレーター) */
524
+ treads: Seg2[];
525
+ /** 輪郭 — 走りの側線・踊り場の縁 */
526
+ outline: Seg2[];
527
+ /** 切断線 (作図慣習の平行な二本の斜線) */
528
+ breaks: Seg2[];
529
+ arrows: RunArrow[];
530
+ /** 注記 (勾配・段数) */
531
+ notes: Array<{ x: number; y: number; text: string }>;
532
+ }
533
+
534
+ /**
535
+ * 上る走りのうち、**切断面より下に残る**区間 (部品ごと、原点の枠での [t0,t1])。
536
+ *
537
+ * 判定は幾何 — 部品の z の範囲と切断面の高さだけで決まる。部品の番号 (何本目か) では
538
+ * 決めない。並列の台は同じ高さで切られるので、この書き方でしか二台目に窓が出ない。
539
+ */
540
+ function upWindows(run: VerticalRun, cutZ: number | undefined): Array<[number, number] | undefined> {
541
+ return run.parts.map((p) => {
542
+ if (cutZ === undefined) return [p.t0, p.t1] as [number, number];
543
+ const lo = Math.min(p.z0, p.z1);
544
+ const hi = Math.max(p.z0, p.z1);
545
+ if (cutZ >= hi - 1) return [p.t0, p.t1] as [number, number]; // 丸ごと切断面より下
546
+ if (cutZ <= lo + 1 || hi - lo < 1) return undefined; // 丸ごと上 (踊り場もここ)
547
+ const t = p.t0 + ((cutZ - p.z0) / (p.z1 - p.z0)) * (p.t1 - p.t0);
548
+ const [a, b] = p.z0 < p.z1 ? [p.t0, t] : [t, p.t1];
549
+ return b - a > 1 ? ([a, b] as [number, number]) : undefined;
550
+ });
551
+ }
552
+
553
+ /**
554
+ * 下りる走りは、**双子の上る走りが隠した残り**に現れる。
555
+ *
556
+ * 平面図が「そのレベルで切った断面」である以上、同じ枠を共有する二つの走りは
557
+ * 補い合う — 上りが切断線までを占め、その先に下りが見える。双子が無い (上る走りが
558
+ * 無い / 枠が違う) なら、下りる走りは丸ごと見える。
559
+ */
560
+ function downWindows(
561
+ run: VerticalRun,
562
+ twin: Array<[number, number] | undefined> | undefined,
563
+ ): Array<[number, number] | undefined> {
564
+ return run.parts.map((p, i) => {
565
+ const w = twin?.[i];
566
+ if (!w) return [p.t0, p.t1] as [number, number];
567
+ const [a, b] = w;
568
+ // 上りが占めたのが手前側 ([t0,t]) なら残りは奥側、逆なら手前側
569
+ const out: [number, number] = a <= p.t0 + 1 ? [b, p.t1] : [p.t0, a];
570
+ return out[1] - out[0] > 1 ? out : undefined;
571
+ });
572
+ }
573
+
574
+ /**
575
+ * そのレベルの平面に現れる縦動線を描く。
576
+ *
577
+ * 一枚の平面には二つの走りが出る — このレベルから**上る**走り (切断線で切れる) と、
578
+ * このレベルへ**下りる**走り (下階の走りを上から見たもの)。切断より先には上る走りは
579
+ * 描かれず、その位置から先に下りる走りが見える。これが階段が階ごとに違う姿で現れる
580
+ * 理由であり、平面図が「そのレベルで切った断面」だという事実そのものである。
581
+ */
582
+ export function runDrawsForLevel(model: Model, level: string, cut = CUT_HEIGHT): RunDraw[] {
583
+ const z = model.levels[level]?.z;
584
+ if (z === undefined) return [];
585
+ const cutZ = z + cut;
586
+ const runs = verticalRuns(model);
587
+ const out: RunDraw[] = [];
588
+ const upRuns = runs.filter((r) => r.level === level);
589
+
590
+ for (const r of upRuns) {
591
+ const wins = r.device === "lift" ? undefined : upWindows(r, cutZ);
592
+ out.push(drawRun(r, wins, r.device === "lift" ? undefined : crossings(r, cutZ), "up"));
593
+ }
594
+ for (const r of runs.filter((x) => x.upper === level)) {
595
+ if (r.device === "lift") continue; // かごの記号は自レベルに一つで足りる
596
+ const twin = upRuns.find((u) => sameFrame(u, r));
597
+ out.push(drawRun(r, downWindows(r, twin ? upWindows(twin, cutZ) : undefined), undefined, "down"));
598
+ }
599
+ return out;
600
+ }
601
+
602
+ /**
603
+ * 同じ枠を共有する走りか。**位置だけでは足りない** — 向き (up) と形 (form) と
604
+ * 台数が揃って初めて部品が番号どおりに対応する。向きが違う走りに双子の切断位置を
605
+ * 当てると、鏡像の平面が出る。
606
+ */
607
+ function sameFrame(a: VerticalRun, b: VerticalRun): boolean {
608
+ return (
609
+ Math.abs(a.rect.x1 - b.rect.x1) < 1 &&
610
+ Math.abs(a.rect.y1 - b.rect.y1) < 1 &&
611
+ Math.abs(a.rect.x2 - b.rect.x2) < 1 &&
612
+ Math.abs(a.rect.y2 - b.rect.y2) < 1 &&
613
+ a.up === b.up &&
614
+ a.form === b.form &&
615
+ a.device === b.device &&
616
+ a.parts.length === b.parts.length
617
+ );
618
+ }
619
+
620
+ /** 走りが切断面を跨ぐ位置 (部品ごと、跨がなければ undefined) */
621
+ function crossings(run: VerticalRun, cutZ: number): Array<number | undefined> {
622
+ return run.parts.map((p) => {
623
+ if (p.kind !== "flight") return undefined;
624
+ const lo = Math.min(p.z0, p.z1);
625
+ const hi = Math.max(p.z0, p.z1);
626
+ if (cutZ < lo || cutZ > hi || hi - lo < 1) return undefined;
627
+ return p.t0 + ((cutZ - p.z0) / (p.z1 - p.z0)) * (p.t1 - p.t0);
628
+ });
629
+ }
630
+
631
+
632
+ function drawRun(
633
+ run: VerticalRun,
634
+ windows: Array<[number, number] | undefined> | undefined,
635
+ cross: Array<number | undefined> | undefined,
636
+ dir: "up" | "down",
637
+ ): RunDraw {
638
+ const draw: RunDraw = {
639
+ path: run.path,
640
+ device: run.device,
641
+ treads: [],
642
+ outline: [],
643
+ breaks: [],
644
+ arrows: [],
645
+ notes: [],
646
+ };
647
+ const { rect, up } = run;
648
+ const seg = (t0: number, s0: number, t1: number, s1: number): Seg2 => {
649
+ const a = toPoint(rect, up, t0, s0);
650
+ const b = toPoint(rect, up, t1, s1);
651
+ return { x1: a.x, y1: a.y, x2: b.x, y2: b.y };
652
+ };
653
+
654
+ if (run.device === "lift") {
655
+ // 昇降機の記号: かごの輪郭と対角線 (作図慣習)
656
+ const m = Math.min(250, run.width / 8);
657
+ const [t0, t1, s0, s1] = [m, run.length - m, m, run.width - m];
658
+ draw.outline.push(
659
+ seg(t0, s0, t1, s0),
660
+ seg(t0, s1, t1, s1),
661
+ seg(t0, s0, t0, s1),
662
+ seg(t1, s0, t1, s1),
663
+ );
664
+ draw.treads.push(seg(t0, s0, t1, s1), seg(t0, s1, t1, s0));
665
+ return draw;
666
+ }
667
+
668
+ for (let i = 0; i < run.parts.length; i++) {
669
+ const p = run.parts[i]!;
670
+ const win = windows ? windows[i] : ([p.t0, p.t1] as [number, number]);
671
+ if (!win) continue;
672
+ const [lo, hi] = win;
673
+ draw.outline.push(seg(lo, p.s0, hi, p.s0), seg(lo, p.s1, hi, p.s1));
674
+ if (p.kind === "landing") continue;
675
+
676
+ if (run.device === "stair") {
677
+ const d = (p.t1 - p.t0) / Math.max(1, (p.risers ?? 2) - 1);
678
+ for (let t = p.t0 + d; t < p.t1 - 1; t += d) {
679
+ if (t < lo - 0.5 || t > hi + 0.5) continue;
680
+ draw.treads.push(seg(t, p.s0, t, p.s1));
681
+ }
682
+ } else if (run.device === "escalator") {
683
+ for (let t = lo + STEP_MARK; t < hi - 1; t += STEP_MARK) {
684
+ draw.treads.push(seg(t, p.s0, t, p.s1));
685
+ }
686
+ }
687
+
688
+ // 矢印: 一台ごと (エスカレーターの上り/下りが並ぶ)。折返しは走りごとには描かず、
689
+ // 出発する走り (上り) / 到着する走り (下り) に一本だけ
690
+ const isFirst = i === run.parts.findIndex((q) => q.kind === "flight");
691
+ const isLast = i === run.parts.map((q) => q.kind).lastIndexOf("flight");
692
+ const wantArrow = run.device === "escalator" ? true : dir === "up" ? isFirst : isLast;
693
+ if (wantArrow && hi - lo > 900) {
694
+ const c = (p.s0 + p.s1) / 2;
695
+ // **矢印は人の進む向きだけから決まる。**reversed が「t の減る向きに進む」、
696
+ // 昇り降りは進む先の高さで決まる。エスカレーターは機械の向きが固定なので
697
+ // どちらの平面でも同じ向きを指し、階段と斜路は下りの平面で反転する
698
+ const partUp = (p.reversed ? p.z0 : p.z1) > (p.reversed ? p.z1 : p.z0);
699
+ const flip = run.device !== "escalator" && dir === "down";
700
+ const goUp = flip ? !partUp : partUp;
701
+ const back = flip ? !p.reversed : p.reversed; // t が減る向きに進むか
702
+ const from = back ? hi - 150 : lo + 150;
703
+ const to = back ? lo + 150 : hi - 150;
704
+ draw.arrows.push({ ...seg(from, c, to, c), label: goUp ? "UP" : "DN" });
705
+ }
706
+ }
707
+
708
+ // 切断線: 走りを横切る平行な二本の斜線 (作図慣習)。交差させると吹抜けの対角線と紛れる
709
+ if (dir === "up" && cross) {
710
+ // 並列の台はどれも同じ高さで切られる。切断線は**跨いだ走りに、その走り自身の
711
+ // 位置で**引く — 一台の位置を全台に配ると、何も無い所に線が乗る
712
+ for (let i = 0; i < run.parts.length; i++) {
713
+ const p = run.parts[i]!;
714
+ const ct = cross[i];
715
+ if (ct === undefined || !windows?.[i]) continue;
716
+ const g = Math.min(300, (p.s1 - p.s0) / 4);
717
+ const off = Math.min(220, g);
718
+ draw.breaks.push(
719
+ seg(ct - g - off, p.s0, ct + g - off, p.s1),
720
+ seg(ct - g + off, p.s0, ct + g + off, p.s1),
721
+ );
722
+ }
723
+ }
724
+
725
+ if (dir === "up") {
726
+ draw.notes.push({
727
+ x: (rect.x1 + rect.x2) / 2,
728
+ y: (rect.y1 + rect.y2) / 2,
729
+ text:
730
+ run.device === "stair"
731
+ ? `${run.risers}段 蹴上${Math.round(run.riser)}/踏面${Math.round(run.tread)}`
732
+ : `${run.lanes > 1 ? `${run.lanes}台 ` : ""}勾配 ${slopeText(run.slope)}`,
733
+ });
734
+ }
735
+ return draw;
736
+ }
737
+
738
+ // ---- 検査の材料 (check.ts が言葉にする) ----
739
+
740
+ /** runIssues が出しうる診断コード (ADR-0016 の台帳の部分集合 — check の emit が型で受ける) */
741
+ export type RunCode = "RUN01" | "RUN02" | "RUN03" | "RUN04" | "RUN05" | "RUN06" | "RUN07" | "RUN08";
742
+
743
+ export interface RunIssue {
744
+ code: RunCode;
745
+ message: string;
746
+ path: string;
747
+ line: number;
748
+ file?: string;
749
+ }
750
+
751
+ /**
752
+ * 縦動線の検査。宣言の妥当性 (RUN01..05) と、**書かれていない導出値**の妥当性
753
+ * (RUN06 段の寸法 / RUN07 勾配 / RUN08 トポロジーの欠落)。
754
+ * 勾配も段数も書かない — だから検査する、という構えの実装 (ADR-0021)。
755
+ */
756
+ export function runIssues(model: Model): RunIssue[] {
757
+ const out: RunIssue[] = [];
758
+ const levels = levelsSorted(model);
759
+ const stairLinked = new Set<string>();
760
+ for (const b of model.boundaries) {
761
+ if (b.kind === "stair" || b.kind === "shaft") {
762
+ stairLinked.add(b.a);
763
+ stairLinked.add(b.b);
764
+ }
765
+ }
766
+
767
+ for (const s of model.spaces.values()) {
768
+ const decls = runDecls(s);
769
+ if (decls.length === 0) continue;
770
+ const at = { path: s.path, line: s.line, ...(s.file !== undefined ? { file: s.file } : {}) };
771
+ if (decls.length > 1) {
772
+ out.push({
773
+ code: "RUN01",
774
+ message: `縦動線の宣言が複数あります: ${decls.map((d) => `${d.device}:${d.value}`).join(" ")} (一つの空間に一つです)`,
775
+ ...at,
776
+ });
777
+ continue;
778
+ }
779
+ const { device, value } = decls[0]!;
780
+ if (device === "lift" ? value !== "1" : !EDGES.has(value)) {
781
+ out.push({
782
+ code: "RUN02",
783
+ message:
784
+ device === "lift"
785
+ ? `lift の値は 1 です: lift:${value}`
786
+ : `${device} の値は上る向き N/E/S/W です: ${device}:${value}`,
787
+ ...at,
788
+ });
789
+ continue;
790
+ }
791
+ if (s.rects.length !== 1) {
792
+ out.push({
793
+ code: "RUN03",
794
+ message:
795
+ s.rects.length === 0
796
+ ? `縦動線には領域が要ります: ${s.path}`
797
+ : `縦動線の領域は矩形一つです (合併は段割りが決まりません): ${s.path}`,
798
+ ...at,
799
+ });
800
+ continue;
801
+ }
802
+ if (!s.level) {
803
+ out.push({ code: "RUN03", message: `縦動線のレベルが特定できません: ${s.path}`, ...at });
804
+ continue;
805
+ }
806
+ const formRaw = String(s.attrs["form"] ?? "straight");
807
+ if (!RUN_FORMS.includes(formRaw as RunForm)) {
808
+ out.push({
809
+ code: "RUN05",
810
+ message: `form は ${RUN_FORMS.join(" / ")} です: form:${formRaw} (螺旋は折返しの連続として書きます)`,
811
+ ...at,
812
+ });
813
+ continue;
814
+ }
815
+ if (device !== "stair" && device !== "ramp" && formRaw !== "straight") {
816
+ out.push({
817
+ code: "RUN05",
818
+ message: `${device} に form:${formRaw} は書けません (折返せるのは階段と斜路です)`,
819
+ ...at,
820
+ });
821
+ continue;
822
+ }
823
+
824
+ const li = levels.findIndex((l) => l.name === s.level);
825
+ if (device !== "lift" && (li < 0 || !levels[li + 1])) {
826
+ out.push({
827
+ code: "RUN04",
828
+ message: `${s.level} の上にレベルが無いため、${s.path} の形は生成されません`,
829
+ ...at,
830
+ });
831
+ continue;
832
+ }
833
+
834
+ const run = verticalRun(model, s, levels);
835
+ if (!run) {
836
+ out.push({
837
+ code: "RUN05",
838
+ message: `縦動線の形が決まりません: ${s.path} (踊り場が全長を超えていないか確かめます)`,
839
+ ...at,
840
+ });
841
+ continue;
842
+ }
843
+ if (device === "lift") continue;
844
+
845
+ if (!stairLinked.has(s.path)) {
846
+ out.push({
847
+ code: "RUN08",
848
+ message: `${s.path} は縦動線の形を持ちますが、上下を繋ぐ垂直境界がありません (stack か boundary type:stair を書きます — 形はあってもグラフでは通れません)`,
849
+ ...at,
850
+ });
851
+ }
852
+
853
+ if (device === "stair") {
854
+ const t = Math.round(run.tread);
855
+ const r = Math.round(run.riser);
856
+ const rule = 2 * r + t;
857
+ if (t < TREAD_MIN || rule < STEP_RULE.lo || rule > STEP_RULE.hi) {
858
+ out.push({
859
+ code: "RUN06",
860
+ message: `導出された段の寸法が窮屈です: ${run.risers}段 蹴上${r}mm / 踏面${t}mm (2×蹴上+踏面 = ${Math.round(rule)}mm、目安 ${STEP_RULE.lo}〜${STEP_RULE.hi}mm)`,
861
+ ...at,
862
+ });
863
+ }
864
+ } else if (device === "ramp") {
865
+ const declared = s.attrs["slope"];
866
+ if (typeof declared === "number" && declared > 0 && run.slope > 1 / declared + 1e-9) {
867
+ out.push({
868
+ code: "RUN07",
869
+ message: `導出された勾配 ${slopeText(run.slope)} が宣言 1/${declared} より急です (走り長を伸ばすか階高を下げます)`,
870
+ ...at,
871
+ });
872
+ }
873
+ } else if (device === "escalator") {
874
+ if (run.slope < ESCALATOR_SLOPE.lo || run.slope > ESCALATOR_SLOPE.hi) {
875
+ out.push({
876
+ code: "RUN07",
877
+ message: `導出された勾配 ${slopeText(run.slope)} はエスカレーターの常用域 (約1/1.7 = 30度) から外れています`,
878
+ ...at,
879
+ });
880
+ }
881
+ }
882
+ }
883
+ return out;
884
+ }