@liminalia/runtime 0.0.0-stage → 0.8.4
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.
- package/LICENSE +106 -0
- package/dist/src/chat.js +60 -0
- package/dist/src/commands-play.js +300 -0
- package/dist/src/commands.js +534 -0
- package/dist/src/coverage.js +208 -0
- package/dist/src/headless.js +109 -0
- package/dist/src/host.js +1 -0
- package/dist/src/index.js +15 -0
- package/dist/src/prefetch.js +80 -0
- package/dist/src/program.js +131 -0
- package/dist/src/project-options.js +84 -0
- package/dist/src/retranslate.js +44 -0
- package/dist/src/route.js +242 -0
- package/dist/src/runtime.js +1929 -0
- package/dist/src/save.js +51 -0
- package/dist/src/scenario-test.js +200 -0
- package/dist/src/state.js +62 -0
- package/dist/src/value.js +464 -0
- package/dist/src/voice-observe.js +82 -0
- package/package.json +33 -4
- package/src/chat.ts +109 -0
- package/src/commands-play.ts +280 -0
- package/src/commands.ts +457 -0
- package/src/coverage.ts +257 -0
- package/src/headless.ts +139 -0
- package/src/host.ts +116 -0
- package/src/index.ts +16 -0
- package/src/prefetch.ts +78 -0
- package/src/program.ts +186 -0
- package/src/project-options.ts +128 -0
- package/src/retranslate.ts +67 -0
- package/src/route.ts +365 -0
- package/src/runtime.ts +2143 -0
- package/src/save.ts +60 -0
- package/src/scenario-test.ts +218 -0
- package/src/state.ts +353 -0
- package/src/value.ts +443 -0
- package/src/voice-observe.ts +85 -0
- package/types/src/chat.d.ts +63 -0
- package/types/src/commands-play.d.ts +2 -0
- package/types/src/commands.d.ts +2 -0
- package/types/src/coverage.d.ts +100 -0
- package/types/src/headless.d.ts +77 -0
- package/types/src/host.d.ts +140 -0
- package/types/src/index.d.ts +16 -0
- package/types/src/prefetch.d.ts +18 -0
- package/types/src/program.d.ts +107 -0
- package/types/src/project-options.d.ts +103 -0
- package/types/src/retranslate.d.ts +39 -0
- package/types/src/route.d.ts +181 -0
- package/types/src/runtime.d.ts +553 -0
- package/types/src/save.d.ts +21 -0
- package/types/src/scenario-test.d.ts +43 -0
- package/types/src/state.d.ts +357 -0
- package/types/src/value.d.ts +61 -0
- package/types/src/voice-observe.d.ts +26 -0
- package/README.md +0 -3
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
export const I18N_FIELD = "i18n";
|
|
2
|
+
/** 引数を読んだときの、訳す印のある文字の元(resolveArgs が付ける)。 */
|
|
3
|
+
const origins = new WeakMap();
|
|
4
|
+
/** 引数の文字の元を控える(実行器の resolveArgs だけが使う)。 */
|
|
5
|
+
export function noteArgOrigin(args, name, origin) {
|
|
6
|
+
let o = origins.get(args);
|
|
7
|
+
if (!o)
|
|
8
|
+
origins.set(args, (o = {}));
|
|
9
|
+
o[name] = origin;
|
|
10
|
+
}
|
|
11
|
+
/**
|
|
12
|
+
* 命令の引数の、訳す印(translate: "text")のある文字の元。字面で書いた文字だけにあり、式で書いた文字には無い。
|
|
13
|
+
* 置いた文字を状態に残す命令は、これを i18n に入れておくと、言語を替えたときに出し直される。
|
|
14
|
+
*/
|
|
15
|
+
export function argOrigin(args, name) {
|
|
16
|
+
return origins.get(args)?.[name];
|
|
17
|
+
}
|
|
18
|
+
/** i18n を一つ作る(元の無い欄は入れない。どれも無ければ undefined)。 */
|
|
19
|
+
export function textOrigins(fields) {
|
|
20
|
+
const out = {};
|
|
21
|
+
for (const [k, v] of Object.entries(fields))
|
|
22
|
+
if (v)
|
|
23
|
+
out[k] = v;
|
|
24
|
+
return Object.keys(out).length > 0 ? out : undefined;
|
|
25
|
+
}
|
|
26
|
+
const isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
|
|
27
|
+
/** stage.extra などの中で、i18n を持つものを順に渡す。 */
|
|
28
|
+
export function* withOrigins(value, depth = 0) {
|
|
29
|
+
if (depth > 12)
|
|
30
|
+
return;
|
|
31
|
+
if (Array.isArray(value)) {
|
|
32
|
+
for (const v of value)
|
|
33
|
+
yield* withOrigins(v, depth + 1);
|
|
34
|
+
return;
|
|
35
|
+
}
|
|
36
|
+
if (!isRecord(value))
|
|
37
|
+
return;
|
|
38
|
+
const own = value[I18N_FIELD];
|
|
39
|
+
if (isRecord(own))
|
|
40
|
+
yield { target: value, origins: own };
|
|
41
|
+
for (const [k, v] of Object.entries(value))
|
|
42
|
+
if (k !== I18N_FIELD && v && typeof v === "object")
|
|
43
|
+
yield* withOrigins(v, depth + 1);
|
|
44
|
+
}
|
|
@@ -0,0 +1,242 @@
|
|
|
1
|
+
import { Runtime } from "./runtime.js";
|
|
2
|
+
import { clonePlain } from "./state.js";
|
|
3
|
+
/** 選択肢の文(画像のボタンで文が無いものは画像の名前)。 */
|
|
4
|
+
function optionTexts(texts, looks) {
|
|
5
|
+
return texts.map((t, i) => t || looks?.[i]?.image || t);
|
|
6
|
+
}
|
|
7
|
+
/** 一回流す。止めた・終わった・上限に達したら返る。 */
|
|
8
|
+
export async function walk(o) {
|
|
9
|
+
const plan = o.plan ?? [];
|
|
10
|
+
const offset = o.offset ?? 0;
|
|
11
|
+
const seen = new Map();
|
|
12
|
+
const start = typeof o.start === "string" ? null : o.start;
|
|
13
|
+
const state = { runtime: null, choices: [], assigned: { ...(start?.assigned ?? {}) } };
|
|
14
|
+
const host = {
|
|
15
|
+
// 人が操作せずに流す(命令の autoplay の答えで進める)
|
|
16
|
+
automated: true,
|
|
17
|
+
loadSource: (file) => o.loadSource(file),
|
|
18
|
+
present: async (event) => {
|
|
19
|
+
o.present?.(event, state);
|
|
20
|
+
if (event.type === "page" && o.page?.(event.key ? { ...event.at, key: event.key } : event.at, state))
|
|
21
|
+
runtime.stop();
|
|
22
|
+
const paused = o.pause?.();
|
|
23
|
+
if (paused)
|
|
24
|
+
await paused;
|
|
25
|
+
},
|
|
26
|
+
waitClick: async () => { },
|
|
27
|
+
choose: async (texts, _signal, looks, targets) => {
|
|
28
|
+
const paused = o.pause?.();
|
|
29
|
+
if (paused)
|
|
30
|
+
await paused;
|
|
31
|
+
const at = runtime.at ?? { file: "", line: 0 };
|
|
32
|
+
if (o.choice?.(at, optionTexts(texts, looks), state, targets)) {
|
|
33
|
+
runtime.stop();
|
|
34
|
+
return null;
|
|
35
|
+
}
|
|
36
|
+
const key = texts.join("\u0000");
|
|
37
|
+
const n = seen.get(key) ?? 0;
|
|
38
|
+
seen.set(key, n + 1);
|
|
39
|
+
const order = o.order?.(at, optionTexts(texts, looks), state, targets);
|
|
40
|
+
if (order && order.length === texts.length) {
|
|
41
|
+
const rank = Math.min(plan[state.choices.length] ?? n % texts.length, texts.length - 1);
|
|
42
|
+
const picked = order[rank];
|
|
43
|
+
state.choices.push({ file: at.file, line: at.line, picked, count: texts.length, text: optionTexts(texts, looks)[picked] ?? "", rank });
|
|
44
|
+
return picked;
|
|
45
|
+
}
|
|
46
|
+
const planned = plan[state.choices.length];
|
|
47
|
+
const picked = Math.min(Math.max(0, planned ?? o.pick?.(at, optionTexts(texts, looks), state, targets) ?? (offset + n) % texts.length), texts.length - 1);
|
|
48
|
+
state.choices.push({ file: at.file, line: at.line, picked, count: texts.length, text: optionTexts(texts, looks)[picked] ?? "" });
|
|
49
|
+
return picked;
|
|
50
|
+
},
|
|
51
|
+
...(o.onDiagnostic ? { onDiagnostic: (d) => o.onDiagnostic(d) } : {}),
|
|
52
|
+
};
|
|
53
|
+
const runtime = new Runtime(host, {
|
|
54
|
+
...o.runtime,
|
|
55
|
+
onAssign: (path, _value, at) => {
|
|
56
|
+
state.assigned[path] = at;
|
|
57
|
+
},
|
|
58
|
+
...(o.step ? { onStep: (at) => o.step(at, state) } : {}),
|
|
59
|
+
});
|
|
60
|
+
state.runtime = runtime;
|
|
61
|
+
if (start) {
|
|
62
|
+
if (start.temp)
|
|
63
|
+
runtime.state.temp = structuredClone(start.temp);
|
|
64
|
+
if (start.system)
|
|
65
|
+
runtime.system = structuredClone(start.system);
|
|
66
|
+
return { result: await runtime.load(start.save), walk: state };
|
|
67
|
+
}
|
|
68
|
+
return { result: await runtime.start(o.start), walk: state };
|
|
69
|
+
}
|
|
70
|
+
/** その時点の様子を控える。 */
|
|
71
|
+
export function capture(walk, at) {
|
|
72
|
+
return {
|
|
73
|
+
save: walk.runtime.save(),
|
|
74
|
+
temp: clonePlain(walk.runtime.state.temp),
|
|
75
|
+
system: clonePlain(walk.runtime.system),
|
|
76
|
+
at,
|
|
77
|
+
choices: walk.choices.map((c) => ({ ...c })),
|
|
78
|
+
assigned: { ...walk.assigned },
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
/**
|
|
82
|
+
* 後戻りの探索で、start から reached に着く道筋を探す。着かなければ、最後の選択を次の番号に変えてやり直す
|
|
83
|
+
* (選び尽くしたらその前の選択へ)。外れの選択でバッドエンドに行った道筋は捨て、着けた最初の道筋を使う。
|
|
84
|
+
* 見つからなければ null。
|
|
85
|
+
*/
|
|
86
|
+
export async function findRoute(o) {
|
|
87
|
+
let plan = [];
|
|
88
|
+
for (let attempt = 0; attempt < (o.attempts ?? 400); attempt++) {
|
|
89
|
+
const box = { found: null };
|
|
90
|
+
const check = (kind, at, w) => {
|
|
91
|
+
if (box.found)
|
|
92
|
+
return false;
|
|
93
|
+
if (!o.reached(kind, at, w))
|
|
94
|
+
return o.giveUp?.(w) ?? false;
|
|
95
|
+
box.found = capture(w, at);
|
|
96
|
+
return true;
|
|
97
|
+
};
|
|
98
|
+
const { walk: w } = await walk({ ...o, plan, page: (at, w) => check("page", { file: at.file, line: at.line }, w), choice: (at, _options, w) => check("choice", at, w) });
|
|
99
|
+
if (box.found)
|
|
100
|
+
return box.found;
|
|
101
|
+
// 最後の選択を次のものに変えてやり直す(試す順があれば、その順の次)
|
|
102
|
+
const choices = w.choices;
|
|
103
|
+
const pos = (c) => c.rank ?? c.picked;
|
|
104
|
+
let i = choices.length - 1;
|
|
105
|
+
while (i >= 0 && pos(choices[i]) + 1 >= choices[i].count)
|
|
106
|
+
i--;
|
|
107
|
+
if (i < 0)
|
|
108
|
+
break;
|
|
109
|
+
plan = [...choices.slice(0, i).map(pos), pos(choices[i]) + 1];
|
|
110
|
+
}
|
|
111
|
+
return null;
|
|
112
|
+
}
|
|
113
|
+
/**
|
|
114
|
+
* 選択肢の選び方を、まだ試していないものへ広げながら何回も流す(全ルートテストと lim coverage)。
|
|
115
|
+
*
|
|
116
|
+
* - 流した選び方を木に覚え、次の回は、まだ試していない「選択肢と番号」の組を一つ選び、そこまでの選び方をなぞってからそれを選ぶ。
|
|
117
|
+
* 選ぶ組は、その選択肢(場所と文)がまだ一度も選ばれていないものを先に、次に浅いもの(先に出る選択肢)を先にする。
|
|
118
|
+
* 試していない組が無くなれば、すべての選び方を試し終えたので止める(complete)。小さな作品は上限までにすべての道を通る。
|
|
119
|
+
* - なぞった先の、初めて出る選択肢では、その場所でまだ選ばれた数の少ない選択肢を選ぶ(同じ選択肢へ戻る輪も、いずれ別のものを選んで抜ける)。
|
|
120
|
+
* - 前の回で通ったのと同じ状態(場所、変数、呼び出し、舞台など)の選択肢に別の選び方で来たら、その先は同じ流れになるので、その回をそこで止める
|
|
121
|
+
* (merged)。ラベルに入った回数と選んだ回数は 2 回以上を同じとみなす(外れを選ぶと戻る輪を何周しても同じ状態にするため)。
|
|
122
|
+
* - random は seed で決まるので、同じ選び方なら同じ流れになる(なぞれる)。
|
|
123
|
+
*/
|
|
124
|
+
export async function explore(o) {
|
|
125
|
+
const { start, runs: limit, signal, choice, begin, ran, ...rest } = o;
|
|
126
|
+
const nodes = new Map();
|
|
127
|
+
const list = [];
|
|
128
|
+
const states = new Set();
|
|
129
|
+
/** 選択肢(場所と文)→ 選んだ回数(すべての回の合計)。 */
|
|
130
|
+
const taken = new Map();
|
|
131
|
+
const takenKey = (site, text) => `${site}\u0000${text}`;
|
|
132
|
+
const prefixOf = (w) => w.choices.map((c) => c.picked).join(",");
|
|
133
|
+
let plan = [];
|
|
134
|
+
let runs = 0;
|
|
135
|
+
while (runs < limit && !signal?.aborted) {
|
|
136
|
+
const index = runs++;
|
|
137
|
+
begin?.(index);
|
|
138
|
+
let merged = false;
|
|
139
|
+
const { result, walk: w } = await walk({
|
|
140
|
+
...rest,
|
|
141
|
+
start,
|
|
142
|
+
choice: (at, options, w, targets) => {
|
|
143
|
+
if (choice?.(at, options, w, targets))
|
|
144
|
+
return true;
|
|
145
|
+
const prefix = prefixOf(w);
|
|
146
|
+
if (nodes.has(prefix))
|
|
147
|
+
return false;
|
|
148
|
+
// 初めて出た選択肢。前に通った状態なら、その先は前の回で試すので止める
|
|
149
|
+
const key = stateKey(w.runtime, at, options);
|
|
150
|
+
if (states.has(key)) {
|
|
151
|
+
merged = true;
|
|
152
|
+
return true;
|
|
153
|
+
}
|
|
154
|
+
states.add(key);
|
|
155
|
+
const node = { prefix: w.choices.map((c) => c.picked), site: `${at.file}:${at.line}`, options, tried: options.map(() => false) };
|
|
156
|
+
nodes.set(prefix, node);
|
|
157
|
+
list.push(node);
|
|
158
|
+
return false;
|
|
159
|
+
},
|
|
160
|
+
pick: (at, options, w) => {
|
|
161
|
+
const i = w.choices.length;
|
|
162
|
+
const site = `${at.file}:${at.line}`;
|
|
163
|
+
let picked = 0;
|
|
164
|
+
if (i < plan.length)
|
|
165
|
+
picked = Math.min(plan[i], options.length - 1);
|
|
166
|
+
else {
|
|
167
|
+
// その場所でまだ選ばれた数の少ないもの(同じなら上のもの)
|
|
168
|
+
let fewest = Infinity;
|
|
169
|
+
options.forEach((text, n) => {
|
|
170
|
+
const count = taken.get(takenKey(site, text)) ?? 0;
|
|
171
|
+
if (count < fewest)
|
|
172
|
+
[fewest, picked] = [count, n];
|
|
173
|
+
});
|
|
174
|
+
}
|
|
175
|
+
const node = nodes.get(prefixOf(w));
|
|
176
|
+
if (node && picked < node.tried.length)
|
|
177
|
+
node.tried[picked] = true;
|
|
178
|
+
const key = takenKey(site, options[picked] ?? "");
|
|
179
|
+
taken.set(key, (taken.get(key) ?? 0) + 1);
|
|
180
|
+
return picked;
|
|
181
|
+
},
|
|
182
|
+
});
|
|
183
|
+
await ran?.({ index, result, walk: w, merged });
|
|
184
|
+
// 次に試す組: まだ選ばれていない選択肢を先に、次に浅いものを先に
|
|
185
|
+
let next = null;
|
|
186
|
+
for (const node of list) {
|
|
187
|
+
for (let n = 0; n < node.tried.length; n++) {
|
|
188
|
+
if (node.tried[n])
|
|
189
|
+
continue;
|
|
190
|
+
const count = taken.get(takenKey(node.site, node.options[n] ?? "")) ?? 0;
|
|
191
|
+
if (!next || count < next.count || (count === next.count && node.prefix.length < next.node.prefix.length))
|
|
192
|
+
next = { node, n, count };
|
|
193
|
+
}
|
|
194
|
+
}
|
|
195
|
+
if (!next)
|
|
196
|
+
return { runs, complete: true };
|
|
197
|
+
plan = [...next.node.prefix, next.n];
|
|
198
|
+
}
|
|
199
|
+
return { runs, complete: false };
|
|
200
|
+
}
|
|
201
|
+
/** 状態の比べ合わせで、ラベルに入った回数と選んだ回数をこの回数までで区別する。 */
|
|
202
|
+
const COUNT_CAP = 2;
|
|
203
|
+
/**
|
|
204
|
+
* 選択肢を出す時点の状態の鍵。同じ鍵なら、その先の流れ(通る行、終わり方、実行時の診断)は同じになる。
|
|
205
|
+
* 場所、出した選択肢、呼び出しの戻り先、変数(game、system、temp、局所変数)、乱数の種、舞台(NVL の読んだ文は除く)、
|
|
206
|
+
* 取っておいた状態、ラベルに入った回数と選んだ回数(COUNT_CAP まで)を見る。本文の出し分けの進み(variants)は流れを変えないので見ない。
|
|
207
|
+
*/
|
|
208
|
+
function stateKey(runtime, at, options) {
|
|
209
|
+
const s = runtime.save();
|
|
210
|
+
const place = (p) => [p.unit, p.index];
|
|
211
|
+
const capped = (r) => (r ? Object.fromEntries(Object.entries(r).map(([k, v]) => [k, Math.min(v, COUNT_CAP)])) : null);
|
|
212
|
+
const { nvlPages: _pages, noclickPage: _noclick, ...stage } = s.stage;
|
|
213
|
+
return stableJson([
|
|
214
|
+
at.file,
|
|
215
|
+
at.line,
|
|
216
|
+
options,
|
|
217
|
+
place(s.position),
|
|
218
|
+
s.callStack.map((f) => [place(f.return), f.locals, f.result ?? null, f.content ?? null, f.scene ?? false]),
|
|
219
|
+
s.locals,
|
|
220
|
+
s.game,
|
|
221
|
+
s.seed,
|
|
222
|
+
capped(s.visits),
|
|
223
|
+
capped(s.chosen),
|
|
224
|
+
stage,
|
|
225
|
+
s.sleep ?? null,
|
|
226
|
+
s.checkpoints ?? null,
|
|
227
|
+
runtime.state.temp,
|
|
228
|
+
runtime.system,
|
|
229
|
+
]);
|
|
230
|
+
}
|
|
231
|
+
/** キーの順によらない JSON(同じ変数を違う順に入れた状態を同じにする)。 */
|
|
232
|
+
function stableJson(v) {
|
|
233
|
+
if (v === null || typeof v !== "object")
|
|
234
|
+
return JSON.stringify(v) ?? "null";
|
|
235
|
+
if (Array.isArray(v))
|
|
236
|
+
return `[${v.map(stableJson).join(",")}]`;
|
|
237
|
+
const o = v;
|
|
238
|
+
const keys = Object.keys(o)
|
|
239
|
+
.filter((k) => o[k] !== undefined)
|
|
240
|
+
.sort();
|
|
241
|
+
return `{${keys.map((k) => `${JSON.stringify(k)}:${stableJson(o[k])}`).join(",")}}`;
|
|
242
|
+
}
|