@syntropika/tembra-sdk 0.2.2 → 0.3.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 (241) hide show
  1. package/README.md +43 -17
  2. package/dist/authoring/types.d.ts +64 -3
  3. package/dist/authoring/wit.d.ts +6 -0
  4. package/dist/bridge/commands.d.ts +1190 -0
  5. package/dist/bridge/identifiers.d.ts +2 -0
  6. package/dist/bridge/kernel.d.ts +18 -107
  7. package/dist/bridge/protocol.d.ts +3 -138
  8. package/dist/browser.d.ts +14 -1
  9. package/dist/browser.js +141 -3332
  10. package/dist/chunks/browser-b8jamxw2.js +3399 -0
  11. package/dist/chunks/execution-nsqc6nrt.js +1419 -0
  12. package/dist/chunks/index-01zk0xqx.js +160 -0
  13. package/dist/chunks/index-3fjdfdfd.js +152 -0
  14. package/dist/chunks/index-aaymjn7v.js +787 -0
  15. package/dist/chunks/index-c1w7z9hx.js +356 -0
  16. package/dist/chunks/index-h8t0n42q.js +738 -0
  17. package/dist/chunks/index-hfds9mzp.js +308 -0
  18. package/dist/chunks/index-kr4x67wt.js +177 -0
  19. package/dist/chunks/index-kr6bnh34.js +117 -0
  20. package/dist/chunks/index-kyt9dj0a.js +1421 -0
  21. package/dist/chunks/index-n1wxzc9w.js +830 -0
  22. package/dist/chunks/index-pvac426d.js +74 -0
  23. package/dist/chunks/index-smyds5ce.js +3234 -0
  24. package/dist/chunks/index-sse8aapb.js +121 -0
  25. package/dist/chunks/index-v6heph77.js +643 -0
  26. package/dist/chunks/index-xrdvnv37.js +3448 -0
  27. package/dist/chunks/index-za4mg94e.js +26 -0
  28. package/dist/chunks/index-zkqmnjj8.js +167 -0
  29. package/dist/coordinator.js +9 -500
  30. package/dist/error.d.ts +2 -0
  31. package/dist/errors.d.ts +3 -0
  32. package/dist/guest.d.ts +173 -0
  33. package/dist/guest.js +26 -0
  34. package/dist/host.d.ts +36 -30
  35. package/dist/host.js +37 -3310
  36. package/dist/http/bytes.d.ts +8 -0
  37. package/dist/http/events.d.ts +7 -0
  38. package/dist/http.d.ts +45 -0
  39. package/dist/http.js +291 -0
  40. package/dist/index.d.ts +2 -0
  41. package/dist/index.js +49 -862
  42. package/dist/infrastructure/rpc/client.d.ts +2 -1
  43. package/dist/infrastructure/rpc/resources.d.ts +28 -0
  44. package/dist/interpreter/abi.d.ts +54 -0
  45. package/dist/interpreter/acquire.d.ts +18 -0
  46. package/dist/interpreter/browser-network.d.ts +52 -0
  47. package/dist/interpreter/browser-port.d.ts +55 -0
  48. package/dist/interpreter/browser.d.ts +79 -0
  49. package/dist/interpreter/cli.d.ts +5 -0
  50. package/dist/interpreter/codec.d.ts +42 -0
  51. package/dist/interpreter/component/execution.d.ts +42 -0
  52. package/dist/interpreter/component/host.d.ts +69 -0
  53. package/dist/interpreter/component/instance.d.ts +40 -0
  54. package/dist/interpreter/component/kernel.d.ts +120 -0
  55. package/dist/interpreter/component/names.d.ts +5 -0
  56. package/dist/interpreter/component/port.d.ts +85 -0
  57. package/dist/interpreter/component/prepared.d.ts +97 -0
  58. package/dist/interpreter/component/resources.d.ts +45 -0
  59. package/dist/interpreter/component/revision.d.ts +87 -0
  60. package/dist/interpreter/component/scope.d.ts +116 -0
  61. package/dist/interpreter/component/streams.d.ts +28 -0
  62. package/dist/interpreter/component/values.d.ts +79 -0
  63. package/dist/interpreter/component/wasi-filesystem.d.ts +21 -0
  64. package/dist/interpreter/component/wasi-host.d.ts +64 -0
  65. package/dist/interpreter/component/wasi-http.d.ts +33 -0
  66. package/dist/interpreter/component/wasi-sockets.d.ts +183 -0
  67. package/dist/interpreter/component/wasi.d.ts +41 -0
  68. package/dist/interpreter/core.d.ts +64 -0
  69. package/dist/interpreter/fetch-http-provider.d.ts +17 -0
  70. package/dist/interpreter/filesystem/contract.d.ts +85 -0
  71. package/dist/interpreter/filesystem/memory.d.ts +3 -0
  72. package/dist/interpreter/filesystem/opfs.d.ts +3 -0
  73. package/dist/interpreter/filesystem/scope.d.ts +35 -0
  74. package/dist/interpreter/filesystem.d.ts +8 -0
  75. package/dist/interpreter/gate.d.ts +6 -0
  76. package/dist/interpreter/host-protocol.d.ts +100 -0
  77. package/dist/interpreter/http-ingress-fetch.d.ts +7 -0
  78. package/dist/interpreter/http-ingress.d.ts +96 -0
  79. package/dist/interpreter/http-provider.d.ts +85 -0
  80. package/dist/interpreter/io.d.ts +20 -0
  81. package/dist/interpreter/mobile.d.ts +149 -0
  82. package/dist/interpreter/native-ingress.d.ts +95 -0
  83. package/dist/interpreter/node-port.d.ts +25 -0
  84. package/dist/interpreter/node.d.ts +36 -0
  85. package/dist/interpreter/revision.d.ts +64 -0
  86. package/dist/interpreter/scope.d.ts +89 -0
  87. package/dist/interpreter/socket-addresses.d.ts +50 -0
  88. package/dist/interpreter/socket-provider.d.ts +110 -0
  89. package/dist/interpreter/standard-cli.d.ts +34 -0
  90. package/dist/interpreter/standard-codec.d.ts +96 -0
  91. package/dist/interpreter/standard-filesystem.d.ts +47 -0
  92. package/dist/interpreter/standard-host.d.ts +71 -0
  93. package/dist/interpreter/standard-http-values.d.ts +159 -0
  94. package/dist/interpreter/standard-http.d.ts +9 -0
  95. package/dist/interpreter/standard-ingress.d.ts +63 -0
  96. package/dist/interpreter/standard-sockets.d.ts +177 -0
  97. package/dist/interpreter/standard-streams.d.ts +218 -0
  98. package/dist/interpreter/standard-system.d.ts +35 -0
  99. package/dist/interpreter/standard-utf8.d.ts +4 -0
  100. package/dist/interpreter/standard.d.ts +18 -0
  101. package/dist/interpreter/types.d.ts +152 -0
  102. package/dist/interpreter/wit-shape.d.ts +92 -0
  103. package/dist/manager.js +5 -332
  104. package/dist/msgpack.js +9 -615
  105. package/dist/node.d.ts +8 -1
  106. package/dist/node.js +248 -3321
  107. package/dist/rpc.js +196 -699
  108. package/dist/runtime/adapters.d.ts +120 -0
  109. package/dist/runtime/adapters.js +38 -0
  110. package/dist/runtime/calls.d.ts +7 -6
  111. package/dist/runtime/lifecycle.d.ts +3 -1
  112. package/dist/runtime/orbs.d.ts +5 -4
  113. package/dist/runtime/references.d.ts +27 -1
  114. package/dist/runtime/reload.d.ts +5 -3
  115. package/dist/runtime/scopes.d.ts +1 -1
  116. package/dist/runtime/signals.d.ts +4 -0
  117. package/dist/runtime/wit-client.d.ts +38 -0
  118. package/dist/telemetry.js +4 -25
  119. package/dist/tooling/build.d.ts +2 -2
  120. package/dist/tooling/client-resources.d.ts +23 -0
  121. package/dist/tooling/client.d.ts +10 -0
  122. package/dist/tooling/component-glue.d.ts +17 -0
  123. package/dist/tooling/component.d.ts +11 -0
  124. package/dist/tooling/index.d.ts +3 -1
  125. package/dist/tooling/index.js +1155 -102
  126. package/dist/tooling/resolver.d.ts +4 -4
  127. package/dist/tooling/typecheck.d.ts +2 -1
  128. package/dist/tooling/types.d.ts +27 -12
  129. package/dist/tooling/wit.d.ts +9 -0
  130. package/dist/wasi/wasi-clocks-types.d.ts +2 -0
  131. package/dist/wasi/wasi-http-client.d.ts +5 -0
  132. package/dist/wasi/wasi-http-types.d.ts +285 -0
  133. package/dist/wasi/wasi-sockets-ip-name-lookup.d.ts +23 -0
  134. package/dist/wasi/wasi-sockets-types.d.ts +146 -0
  135. package/package.json +62 -35
  136. package/src/authoring/declaration.ts +1 -1
  137. package/src/authoring/types.ts +53 -3
  138. package/src/authoring/wit.ts +15 -0
  139. package/src/bridge/commands.ts +1105 -0
  140. package/src/bridge/identifiers.ts +2 -0
  141. package/src/bridge/kernel.ts +56 -98
  142. package/src/bridge/protocol.ts +3 -142
  143. package/src/browser.ts +90 -6
  144. package/src/context-key.ts +4 -7
  145. package/src/error.ts +1 -1
  146. package/src/errors.ts +7 -0
  147. package/src/guest.ts +327 -0
  148. package/src/host.ts +128 -23
  149. package/src/http/bytes.ts +87 -0
  150. package/src/http/events.ts +34 -0
  151. package/src/http.ts +272 -0
  152. package/src/index.ts +3 -0
  153. package/src/infrastructure/rpc/client.ts +136 -17
  154. package/src/infrastructure/rpc/resources.ts +123 -0
  155. package/src/interpreter/abi.ts +69 -0
  156. package/src/interpreter/acquire.ts +58 -0
  157. package/src/interpreter/browser-network.ts +170 -0
  158. package/src/interpreter/browser-port.ts +425 -0
  159. package/src/interpreter/browser.ts +340 -0
  160. package/src/interpreter/cli.ts +30 -0
  161. package/src/interpreter/codec.ts +298 -0
  162. package/src/interpreter/component/execution.ts +264 -0
  163. package/src/interpreter/component/host.ts +409 -0
  164. package/src/interpreter/component/instance.ts +138 -0
  165. package/src/interpreter/component/kernel.ts +611 -0
  166. package/src/interpreter/component/names.ts +13 -0
  167. package/src/interpreter/component/port.ts +598 -0
  168. package/src/interpreter/component/prepared.ts +194 -0
  169. package/src/interpreter/component/resources.ts +345 -0
  170. package/src/interpreter/component/revision.ts +702 -0
  171. package/src/interpreter/component/scope.ts +447 -0
  172. package/src/interpreter/component/streams.ts +180 -0
  173. package/src/interpreter/component/values.ts +254 -0
  174. package/src/interpreter/component/wasi-filesystem.ts +472 -0
  175. package/src/interpreter/component/wasi-host.ts +197 -0
  176. package/src/interpreter/component/wasi-http.ts +939 -0
  177. package/src/interpreter/component/wasi-sockets.ts +958 -0
  178. package/src/interpreter/component/wasi.ts +238 -0
  179. package/src/interpreter/core.ts +386 -0
  180. package/src/interpreter/fetch-http-provider.ts +98 -0
  181. package/src/interpreter/filesystem/contract.ts +138 -0
  182. package/src/interpreter/filesystem/memory.ts +180 -0
  183. package/src/interpreter/filesystem/opfs.ts +294 -0
  184. package/src/interpreter/filesystem/scope.ts +390 -0
  185. package/src/interpreter/filesystem.ts +20 -0
  186. package/src/interpreter/gate.ts +55 -0
  187. package/src/interpreter/host-protocol.ts +242 -0
  188. package/src/interpreter/http-ingress-fetch.ts +133 -0
  189. package/src/interpreter/http-ingress.ts +203 -0
  190. package/src/interpreter/http-provider.ts +105 -0
  191. package/src/interpreter/io.ts +66 -0
  192. package/src/interpreter/mobile.ts +385 -0
  193. package/src/interpreter/native-ingress.ts +550 -0
  194. package/src/interpreter/node-port.ts +218 -0
  195. package/src/interpreter/node.ts +114 -0
  196. package/src/interpreter/revision.ts +450 -0
  197. package/src/interpreter/scope.ts +453 -0
  198. package/src/interpreter/socket-addresses.ts +246 -0
  199. package/src/interpreter/socket-provider.ts +126 -0
  200. package/src/interpreter/standard-cli.ts +184 -0
  201. package/src/interpreter/standard-codec.ts +403 -0
  202. package/src/interpreter/standard-filesystem.ts +545 -0
  203. package/src/interpreter/standard-host.ts +840 -0
  204. package/src/interpreter/standard-http-values.ts +624 -0
  205. package/src/interpreter/standard-http.ts +622 -0
  206. package/src/interpreter/standard-ingress.ts +344 -0
  207. package/src/interpreter/standard-sockets.ts +847 -0
  208. package/src/interpreter/standard-streams.ts +710 -0
  209. package/src/interpreter/standard-system.ts +182 -0
  210. package/src/interpreter/standard-utf8.ts +72 -0
  211. package/src/interpreter/standard.ts +283 -0
  212. package/src/interpreter/types.ts +163 -0
  213. package/src/interpreter/wit-shape.ts +175 -0
  214. package/src/node.ts +43 -14
  215. package/src/runtime/activities.ts +6 -6
  216. package/src/runtime/adapters.ts +314 -0
  217. package/src/runtime/calls.ts +213 -90
  218. package/src/runtime/context.ts +7 -7
  219. package/src/runtime/lifecycle.ts +36 -17
  220. package/src/runtime/orbs.ts +81 -39
  221. package/src/runtime/programs.ts +16 -8
  222. package/src/runtime/references.ts +128 -11
  223. package/src/runtime/reload.ts +71 -30
  224. package/src/runtime/resources.ts +2 -2
  225. package/src/runtime/scopes.ts +17 -17
  226. package/src/runtime/session.ts +3 -1
  227. package/src/runtime/signals.ts +31 -0
  228. package/src/runtime/wit-client.ts +228 -0
  229. package/src/tooling/build.ts +152 -54
  230. package/src/tooling/client-resources.ts +74 -0
  231. package/src/tooling/client.ts +531 -0
  232. package/src/tooling/component-glue.ts +288 -0
  233. package/src/tooling/component.ts +225 -0
  234. package/src/tooling/index.ts +3 -7
  235. package/src/tooling/resolver.ts +42 -25
  236. package/src/tooling/typecheck.ts +59 -4
  237. package/src/tooling/types.ts +27 -12
  238. package/src/tooling/wit.ts +188 -0
  239. package/dist/embedded.d.ts +0 -1
  240. package/dist/embedded.js +0 -1
  241. package/src/embedded.ts +0 -301
@@ -0,0 +1,830 @@
1
+ // src/interpreter/component/prepared.ts
2
+ var PREPARED_FORMAT = 1;
3
+ var PREPARED_GENERATOR = "@bytecodealliance/jco-transpile@0.23.0";
4
+ var PREPARED_MAXIMUM_PAGES = 65536;
5
+ var COMPONENT_CORE = /^orb\.core[0-9]*\.wasm$/;
6
+ var TRAMPOLINE_CORE = /^orb\.conditional-(?:host-import-[0-9]+|suspending-(?:[123]-i32-to-i32|3-i32-to-void))\.wasm$/;
7
+
8
+ class BrowserPlatformError2 extends Error {
9
+ name = "BrowserPlatformError";
10
+ }
11
+ var records = new WeakMap;
12
+ var invalid = (detail) => new TypeError(`Invalid prepared component module (${detail}); rebuild it with Tembra tooling`);
13
+ function names(value, field) {
14
+ if (!Array.isArray(value) || value.some((name) => typeof name !== "string"))
15
+ throw invalid(`${field} must list names`);
16
+ if (new Set(value).size !== value.length)
17
+ throw invalid(`duplicate ${field} name`);
18
+ return Object.freeze([...value]);
19
+ }
20
+ function preparedComponent2(source) {
21
+ if (source?.format !== PREPARED_FORMAT)
22
+ throw invalid("unsupported format");
23
+ if (source.generator !== PREPARED_GENERATOR)
24
+ throw invalid(`generated by ${String(source.generator)}, expected ${PREPARED_GENERATOR}`);
25
+ const orb = source.orb;
26
+ if (typeof orb?.name !== "string" || !orb.name || !Number.isSafeInteger(orb.apiVersion) || orb.apiVersion <= 0)
27
+ throw invalid("orb identity");
28
+ if (typeof source.artifact !== "string" || !/^[0-9a-f]{64}$/.test(source.artifact))
29
+ throw invalid("artifact digest");
30
+ if (!Number.isSafeInteger(source.maximumPages) || source.maximumPages < 1 || source.maximumPages > PREPARED_MAXIMUM_PAGES)
31
+ throw invalid("maximum pages");
32
+ if (typeof source.instantiate !== "function")
33
+ throw invalid("instantiate");
34
+ if (!Array.isArray(source.cores))
35
+ throw invalid("cores");
36
+ const cores = source.cores.map((core) => {
37
+ if (typeof core?.name !== "string" || typeof core.load !== "function")
38
+ throw invalid("core module");
39
+ if (COMPONENT_CORE.test(core.name)) {
40
+ if (!Number.isSafeInteger(core.pages) || core.pages < 0 || core.pages > source.maximumPages)
41
+ throw invalid(`initial pages of ${core.name}`);
42
+ return Object.freeze({ name: core.name, pages: core.pages, load: core.load });
43
+ }
44
+ if (TRAMPOLINE_CORE.test(core.name) && core.pages === undefined)
45
+ return Object.freeze({ name: core.name, load: core.load });
46
+ throw invalid(`unexpected core module ${core.name}`);
47
+ });
48
+ if (new Set(cores.map((core) => core.name)).size !== cores.length)
49
+ throw invalid("duplicate core module");
50
+ if (!cores.some((core) => core.pages !== undefined))
51
+ throw invalid("no component core module");
52
+ const identity = Object.freeze({ name: orb.name, apiVersion: orb.apiVersion });
53
+ const record = {
54
+ orb: identity,
55
+ artifact: source.artifact,
56
+ maximumPages: source.maximumPages,
57
+ imports: names(source.imports, "import"),
58
+ suspending: new Set(names(source.suspending, "suspending import")),
59
+ promising: new Set(names(source.promising, "promising export")),
60
+ cores: Object.freeze(cores),
61
+ instantiate: source.instantiate
62
+ };
63
+ const component = Object.freeze({
64
+ orb: identity,
65
+ artifact: source.artifact
66
+ });
67
+ records.set(component, record);
68
+ return component;
69
+ }
70
+ function preparedRegistry(components) {
71
+ const registry = new Map;
72
+ if (components === undefined)
73
+ return registry;
74
+ if (!Array.isArray(components))
75
+ throw new TypeError("isolated.components must list prepared components");
76
+ for (const component of components) {
77
+ const record = records.get(component);
78
+ if (!record)
79
+ throw new TypeError("isolated.components accepts only modules generated by Tembra tooling (build with " + "`browser: true`) and imported from the same @syntropika/tembra-sdk");
80
+ const existing = registry.get(record.artifact);
81
+ if (existing && existing !== record)
82
+ throw new TypeError(`Two prepared components are registered for artifact ${record.artifact}`);
83
+ registry.set(record.artifact, record);
84
+ }
85
+ return registry;
86
+ }
87
+
88
+ // src/interpreter/filesystem/contract.ts
89
+ class FilesystemError2 extends Error {
90
+ code;
91
+ constructor(code, message = code) {
92
+ super(message);
93
+ this.code = code;
94
+ }
95
+ }
96
+ function fail(code, message) {
97
+ throw new FilesystemError2(code, message);
98
+ }
99
+ // src/interpreter/filesystem/scope.ts
100
+ var owners = new WeakMap;
101
+
102
+ class Scope {
103
+ store;
104
+ writable;
105
+ #closed = false;
106
+ #opened = new Set;
107
+ #pending = new Set;
108
+ constructor(store, writable) {
109
+ this.store = store;
110
+ this.writable = writable;
111
+ }
112
+ openRoot() {
113
+ if (this.#closed)
114
+ fail("bad-descriptor", "Filesystem mount is closed");
115
+ return this.adopt(this.store.root, this.writable, false);
116
+ }
117
+ async dispose() {
118
+ if (!this.#closed) {
119
+ this.#closed = true;
120
+ for (const opened of this.#opened)
121
+ this.close(opened);
122
+ }
123
+ await Promise.allSettled([...this.#pending]);
124
+ }
125
+ adopt(node, writable, retained) {
126
+ if (this.#closed)
127
+ fail("bad-descriptor", "Filesystem mount is closed");
128
+ const opened = { scope: this, node, writable, retained, closed: false };
129
+ this.#opened.add(opened);
130
+ const descriptor = this.store.type(node) === "file" ? fileDescriptor(opened) : directoryDescriptor(opened);
131
+ owners.set(descriptor, opened);
132
+ return descriptor;
133
+ }
134
+ close(opened) {
135
+ if (opened.closed)
136
+ return;
137
+ opened.closed = true;
138
+ this.#opened.delete(opened);
139
+ if (opened.retained)
140
+ this.store.release(opened.node);
141
+ }
142
+ run(opened, mutate, operation) {
143
+ let promise;
144
+ try {
145
+ live(opened);
146
+ if (mutate && !opened.writable)
147
+ fail("not-permitted", "Descriptor is read-only");
148
+ promise = operation(this.store, opened.node);
149
+ } catch (error) {
150
+ return Promise.reject(error);
151
+ }
152
+ this.#pending.add(promise);
153
+ const forget = () => this.#pending.delete(promise);
154
+ promise.then(forget, forget);
155
+ return promise;
156
+ }
157
+ }
158
+ function live(opened) {
159
+ if (opened.closed)
160
+ fail("bad-descriptor", "Descriptor is closed");
161
+ }
162
+ function size(value, limit, extra = 0) {
163
+ if (typeof value !== "bigint" || value < 0n)
164
+ fail("invalid", "Invalid file position");
165
+ if (value + BigInt(extra) > BigInt(limit))
166
+ fail("file-too-large", "File size limit exceeded");
167
+ return Number(value);
168
+ }
169
+ function bytes(data) {
170
+ if (!(data instanceof Uint8Array))
171
+ fail("invalid", "File data must be a Uint8Array");
172
+ return data;
173
+ }
174
+ async function resolve(store, base, path) {
175
+ if (typeof path !== "string" || path.includes("\x00"))
176
+ fail("invalid", "Invalid path");
177
+ if (path === "")
178
+ fail("no-entry", "Empty path");
179
+ if (path.startsWith("/"))
180
+ fail("not-permitted", "Absolute paths are not permitted");
181
+ const parts = path.split("/").filter((part) => part !== "" && part !== ".");
182
+ const stack = [base];
183
+ const directory = path.endsWith("/");
184
+ for (const [index, part] of parts.entries()) {
185
+ if (part === "..") {
186
+ if (stack.length === 1)
187
+ fail("not-permitted", "Path escapes the opened directory");
188
+ stack.pop();
189
+ } else if (index === parts.length - 1) {
190
+ return { parent: stack.at(-1), name: part, directory };
191
+ } else {
192
+ const child = await store.lookup(stack.at(-1), part, "directory");
193
+ if (store.type(child) !== "directory")
194
+ fail("not-directory", "Path component is a file");
195
+ stack.push(child);
196
+ }
197
+ }
198
+ return { parent: stack.at(-1), directory };
199
+ }
200
+ async function existing(store, base, path) {
201
+ const target = await resolve(store, base, path);
202
+ if (target.name === undefined)
203
+ return target.parent;
204
+ const node = await store.lookup(target.parent, target.name);
205
+ if (target.directory && store.type(node) !== "directory")
206
+ fail("not-directory", "Path is not a directory");
207
+ return node;
208
+ }
209
+ async function named(store, base, path) {
210
+ const target = await resolve(store, base, path);
211
+ if (target.name === undefined)
212
+ fail("invalid", "Path names the opened directory itself");
213
+ return target;
214
+ }
215
+ function descriptorBase(opened) {
216
+ const { scope } = opened;
217
+ return {
218
+ writable: opened.writable,
219
+ stat: () => scope.run(opened, false, (store, node) => store.stat(node)),
220
+ isSameObject: (other) => scope.run(opened, false, async (store, node) => {
221
+ const target = owners.get(other);
222
+ if (!target || target.scope.store !== store)
223
+ return false;
224
+ live(target);
225
+ return store.same(node, target.node);
226
+ }),
227
+ sync: () => scope.run(opened, false, (store, node) => store.sync(node)),
228
+ close: () => scope.close(opened)
229
+ };
230
+ }
231
+ function fileDescriptor(opened) {
232
+ const { scope } = opened;
233
+ return Object.freeze({
234
+ type: "file",
235
+ ...descriptorBase(opened),
236
+ read: (offset, length) => scope.run(opened, false, async (store, node) => {
237
+ if (typeof offset !== "bigint" || offset < 0n || !Number.isSafeInteger(length) || length < 0)
238
+ fail("invalid", "Invalid file range");
239
+ if (length === 0 || offset > BigInt(store.limit))
240
+ return new Uint8Array(0);
241
+ return store.read(node, Number(offset), length);
242
+ }),
243
+ write: (offset, data) => scope.run(opened, true, async (store, node) => {
244
+ const position = size(offset, store.limit, bytes(data).byteLength);
245
+ if (data.byteLength)
246
+ await store.write(node, position, data);
247
+ }),
248
+ append: (data) => scope.run(opened, true, async (store, node) => {
249
+ if (bytes(data).byteLength)
250
+ await store.write(node, undefined, data);
251
+ }),
252
+ setSize: (value) => scope.run(opened, true, (store, node) => store.resize(node, size(value, store.limit))),
253
+ writeStream: (chunks, offset) => scope.run(opened, true, async (store, node) => {
254
+ let position = offset === undefined ? undefined : size(offset, store.limit);
255
+ const checked = async function* () {
256
+ for await (const chunk of chunks) {
257
+ live(opened);
258
+ if (bytes(chunk).byteLength)
259
+ yield chunk;
260
+ }
261
+ }();
262
+ if (store.writeStream)
263
+ return store.writeStream(node, position, checked);
264
+ for await (const chunk of checked) {
265
+ if (position !== undefined && position + chunk.byteLength > store.limit)
266
+ fail("file-too-large", "File size limit exceeded");
267
+ await store.write(node, position, chunk);
268
+ if (position !== undefined)
269
+ position += chunk.byteLength;
270
+ }
271
+ })
272
+ });
273
+ }
274
+ function directoryDescriptor(opened) {
275
+ const { scope } = opened;
276
+ const base = descriptorBase(opened);
277
+ return Object.freeze({
278
+ type: "directory",
279
+ ...base,
280
+ openAt: (path, options = {}) => {
281
+ const { create = false, exclusive = false, truncate = false, write = false } = options;
282
+ return scope.run(opened, create || truncate || write, async (store, node) => {
283
+ if (truncate && !write)
284
+ fail("invalid", "Truncation requires write access");
285
+ if (create && options.directory)
286
+ fail("invalid", "Use createDirectoryAt for directories");
287
+ const target = await resolve(store, node, path);
288
+ const directory = options.directory === true || target.directory;
289
+ let child;
290
+ if (target.name === undefined) {
291
+ if (create && exclusive)
292
+ fail("exist", "Path names an existing directory");
293
+ child = target.parent;
294
+ } else if (create && exclusive) {
295
+ child = await store.create(target.parent, target.name, "file");
296
+ } else {
297
+ child = await openExisting(store, target.parent, target.name, create, directory);
298
+ }
299
+ const type = store.type(child);
300
+ if (directory && type !== "directory")
301
+ fail("not-directory", "Path is not a directory");
302
+ if (truncate && type === "directory")
303
+ fail("is-directory", "Cannot truncate a directory");
304
+ const retained = await store.retain(child);
305
+ try {
306
+ if (truncate)
307
+ await store.resize(retained, 0);
308
+ return scope.adopt(retained, write, true);
309
+ } catch (error) {
310
+ store.release(retained);
311
+ throw error;
312
+ }
313
+ });
314
+ },
315
+ statAt: (path) => scope.run(opened, false, async (store, node) => store.stat(await existing(store, node, path))),
316
+ readDirectory: () => entries(opened),
317
+ createDirectoryAt: (path) => scope.run(opened, true, async (store, node) => {
318
+ const target = await resolve(store, node, path);
319
+ if (target.name === undefined)
320
+ fail("exist", "Directory already exists");
321
+ await store.create(target.parent, target.name, "directory");
322
+ }),
323
+ removeDirectoryAt: (path) => scope.run(opened, true, async (store, node) => {
324
+ const target = await named(store, node, path);
325
+ await store.remove(target.parent, target.name, "directory");
326
+ }),
327
+ unlinkFileAt: (path) => scope.run(opened, true, async (store, node) => {
328
+ const target = await named(store, node, path);
329
+ if (target.directory) {
330
+ const child = await store.lookup(target.parent, target.name);
331
+ fail(store.type(child) === "file" ? "not-directory" : "is-directory", "Not a file path");
332
+ }
333
+ await store.remove(target.parent, target.name, "file");
334
+ }),
335
+ renameAt: (oldPath, newDirectory, newPath) => scope.run(opened, true, async (store, node) => {
336
+ const target = owners.get(newDirectory);
337
+ if (!target || target.scope.store !== store)
338
+ fail("cross-device", "Rename target belongs to another storage");
339
+ live(target);
340
+ if (store.type(target.node) !== "directory")
341
+ fail("not-directory", "Target is a file");
342
+ if (!target.writable)
343
+ fail("not-permitted", "Target directory is read-only");
344
+ const from = await named(store, node, oldPath);
345
+ const to = await named(store, target.node, newPath);
346
+ await store.rename(from.parent, from.name, to.parent, to.name);
347
+ })
348
+ });
349
+ }
350
+ async function openExisting(store, parent, name, create, directory) {
351
+ const expected = directory ? "directory" : "file";
352
+ try {
353
+ return await store.lookup(parent, name, expected);
354
+ } catch (error) {
355
+ if (!create || !(error instanceof FilesystemError2) || error.code !== "no-entry")
356
+ throw error;
357
+ }
358
+ try {
359
+ return await store.create(parent, name, "file");
360
+ } catch (error) {
361
+ if (!(error instanceof FilesystemError2) || error.code !== "exist")
362
+ throw error;
363
+ return store.lookup(parent, name, expected);
364
+ }
365
+ }
366
+ function entries(opened) {
367
+ let source;
368
+ let done = false;
369
+ const finished = { done: true, value: undefined };
370
+ const iterator = {
371
+ next() {
372
+ if (done)
373
+ return Promise.resolve(finished);
374
+ return opened.scope.run(opened, false, async (store, node) => {
375
+ source ??= store.entries(node);
376
+ const step = await source.next();
377
+ if (step.done)
378
+ done = true;
379
+ return step;
380
+ });
381
+ },
382
+ async return() {
383
+ done = true;
384
+ await source?.return?.();
385
+ return finished;
386
+ },
387
+ [Symbol.asyncIterator]() {
388
+ return iterator;
389
+ }
390
+ };
391
+ return iterator;
392
+ }
393
+ function provider(store) {
394
+ return Object.freeze({
395
+ open: (_mount, writable) => new Scope(store, writable)
396
+ });
397
+ }
398
+
399
+ // src/interpreter/filesystem/memory.ts
400
+ var MEMORY_LIMIT = 2 ** 31 - 1;
401
+
402
+ class MemoryFile {
403
+ type = "file";
404
+ data = new Uint8Array(0);
405
+ size = 0;
406
+ modified = Date.now();
407
+ }
408
+
409
+ class MemoryDirectory {
410
+ parent;
411
+ type = "directory";
412
+ children = new Map;
413
+ modified = Date.now();
414
+ removed = false;
415
+ constructor(parent) {
416
+ this.parent = parent;
417
+ }
418
+ }
419
+ function allocate(length) {
420
+ try {
421
+ return new Uint8Array(length);
422
+ } catch {
423
+ return fail("insufficient-memory", "Memory file allocation failed");
424
+ }
425
+ }
426
+ function reserve(file, end) {
427
+ if (end <= file.data.length)
428
+ return;
429
+ const next = allocate(Math.max(end, Math.min(MEMORY_LIMIT, file.data.length * 2 || 64)));
430
+ next.set(file.data.subarray(0, file.size));
431
+ file.data = next;
432
+ }
433
+ function child(parent, name) {
434
+ return parent.children.get(name) ?? fail("no-entry", "No such file or directory");
435
+ }
436
+ function attach(parent, name, node) {
437
+ if (parent.removed)
438
+ fail("no-entry", "Directory was removed");
439
+ parent.children.set(name, node);
440
+ if (node.type === "directory")
441
+ node.parent = parent;
442
+ parent.modified = Date.now();
443
+ }
444
+ function detach(parent, name, node) {
445
+ parent.children.delete(name);
446
+ parent.modified = Date.now();
447
+ if (node.type === "directory") {
448
+ node.parent = undefined;
449
+ node.removed = true;
450
+ }
451
+ }
452
+ function memoryStore(root) {
453
+ const directory = (node) => node;
454
+ const file = (node) => node;
455
+ return {
456
+ root,
457
+ limit: MEMORY_LIMIT,
458
+ type: (node) => node.type,
459
+ lookup: async (parent, name) => child(directory(parent), name),
460
+ async create(parent, name, type) {
461
+ const into = directory(parent);
462
+ if (into.children.has(name))
463
+ fail("exist", "Entry already exists");
464
+ const node = type === "file" ? new MemoryFile : new MemoryDirectory(into);
465
+ attach(into, name, node);
466
+ return node;
467
+ },
468
+ retain: async (node) => node,
469
+ release() {},
470
+ async stat(node) {
471
+ return node.type === "file" ? { type: "file", size: BigInt(node.size), modified: node.modified } : { type: "directory", size: 0n, modified: node.modified };
472
+ },
473
+ same: async (a, b) => a === b,
474
+ async* entries(node) {
475
+ for (const [name, entry] of directory(node).children)
476
+ yield { name, type: entry.type };
477
+ },
478
+ async read(node, offset, length) {
479
+ const target = file(node);
480
+ if (offset >= target.size)
481
+ return new Uint8Array(0);
482
+ return target.data.slice(offset, Math.min(target.size, offset + length));
483
+ },
484
+ async write(node, offset, data) {
485
+ const target = file(node);
486
+ const start = offset ?? target.size;
487
+ const end = start + data.byteLength;
488
+ if (end > MEMORY_LIMIT)
489
+ fail("file-too-large", "Memory file limit exceeded");
490
+ reserve(target, end);
491
+ target.data.set(data, start);
492
+ target.size = Math.max(target.size, end);
493
+ target.modified = Date.now();
494
+ },
495
+ async resize(node, size) {
496
+ const target = file(node);
497
+ if (size < target.size) {
498
+ if (size < target.data.length / 4) {
499
+ const next = allocate(size);
500
+ next.set(target.data.subarray(0, size));
501
+ target.data = next;
502
+ } else
503
+ target.data.fill(0, size, target.size);
504
+ } else
505
+ reserve(target, size);
506
+ target.size = size;
507
+ target.modified = Date.now();
508
+ },
509
+ async sync() {},
510
+ async remove(parent, name, type) {
511
+ const from = directory(parent);
512
+ const node = child(from, name);
513
+ if (node.type !== type)
514
+ fail(type === "file" ? "is-directory" : "not-directory", "Entry has another type");
515
+ if (node.type === "directory" && node.children.size)
516
+ fail("not-empty", "Directory is not empty");
517
+ detach(from, name, node);
518
+ },
519
+ async rename(fromNode, fromName, toNode, toName) {
520
+ const from = directory(fromNode);
521
+ const to = directory(toNode);
522
+ const node = child(from, fromName);
523
+ if (to.removed)
524
+ fail("no-entry", "Directory was removed");
525
+ const replaced = to.children.get(toName);
526
+ if (replaced === node)
527
+ return;
528
+ if (node.type === "directory") {
529
+ for (let ancestor = to;ancestor; ancestor = ancestor.parent)
530
+ if (ancestor === node)
531
+ fail("invalid", "Cannot move a directory into itself");
532
+ }
533
+ if (replaced) {
534
+ if (node.type === "file" && replaced.type === "directory")
535
+ fail("is-directory", "Target is a directory");
536
+ if (node.type === "directory" && replaced.type === "file")
537
+ fail("not-directory", "Target is not a directory");
538
+ if (replaced.type === "directory" && replaced.children.size)
539
+ fail("not-empty", "Target directory is not empty");
540
+ detach(to, toName, replaced);
541
+ }
542
+ detach(from, fromName, node);
543
+ if (node.type === "directory")
544
+ node.removed = false;
545
+ attach(to, toName, node);
546
+ }
547
+ };
548
+ }
549
+ function memoryFilesystem2(files = {}) {
550
+ const root = new MemoryDirectory(undefined);
551
+ const encoder = new TextEncoder;
552
+ for (const [path, value] of Object.entries(files)) {
553
+ const segments = path.split("/");
554
+ if (segments.some((part) => !part || part === "." || part === ".." || part.includes("\x00")))
555
+ throw new Error("Memory filesystem paths must be normalized relative paths");
556
+ let parent = root;
557
+ for (const segment of segments.slice(0, -1)) {
558
+ let next = parent.children.get(segment);
559
+ if (!next)
560
+ attach(parent, segment, next = new MemoryDirectory(parent));
561
+ if (next.type !== "directory")
562
+ throw new Error("Memory path overlaps a file");
563
+ parent = next;
564
+ }
565
+ const name = segments.at(-1);
566
+ if (parent.children.has(name))
567
+ throw new Error("Memory path overlaps a file");
568
+ const node = new MemoryFile;
569
+ node.data = typeof value === "string" ? encoder.encode(value) : value.slice();
570
+ node.size = node.data.byteLength;
571
+ attach(parent, name, node);
572
+ }
573
+ return provider(memoryStore(root));
574
+ }
575
+ // src/interpreter/filesystem/opfs.ts
576
+ var DOM_ERRORS = {
577
+ NotFoundError: "no-entry",
578
+ TypeMismatchError: "not-directory",
579
+ InvalidModificationError: "not-empty",
580
+ NotAllowedError: "access",
581
+ SecurityError: "access",
582
+ QuotaExceededError: "insufficient-space",
583
+ NoModificationAllowedError: "busy",
584
+ NotSupportedError: "unsupported",
585
+ TypeError: "invalid"
586
+ };
587
+ function platformError(error, overrides = {}) {
588
+ if (error instanceof FilesystemError2)
589
+ throw error;
590
+ const name = String(error?.name);
591
+ const message = error instanceof Error ? error.message : String(error);
592
+ throw new FilesystemError2(overrides[name] ?? DOM_ERRORS[name] ?? "io", message);
593
+ }
594
+ function opfsStore(root) {
595
+ const retained = new Map;
596
+ const queues = new WeakMap;
597
+ let registry = Promise.resolve();
598
+ const guard = async (operation, overrides) => {
599
+ try {
600
+ return await operation();
601
+ } catch (error) {
602
+ return platformError(error, overrides);
603
+ }
604
+ };
605
+ const serialize = (handle, operation) => {
606
+ const result = (queues.get(handle) ?? Promise.resolve()).then(operation);
607
+ queues.set(handle, result.catch(() => {}));
608
+ return result;
609
+ };
610
+ const canonical = async (handle) => {
611
+ for (const entry of retained.get(handle.name) ?? [])
612
+ if (await entry.handle.isSameEntry(handle))
613
+ return entry;
614
+ return;
615
+ };
616
+ const optional = async (parent, name) => {
617
+ try {
618
+ return await lookup(parent, name);
619
+ } catch (error) {
620
+ if (error instanceof FilesystemError2 && error.code === "no-entry")
621
+ return;
622
+ throw error;
623
+ }
624
+ };
625
+ const lookup = (parent, name, expected = "file") => guard(async () => {
626
+ const directory = parent;
627
+ const first = () => expected === "file" ? directory.getFileHandle(name) : directory.getDirectoryHandle(name);
628
+ const second = () => expected === "file" ? directory.getDirectoryHandle(name) : directory.getFileHandle(name);
629
+ try {
630
+ return await first();
631
+ } catch (error) {
632
+ if (error?.name !== "TypeMismatchError")
633
+ throw error;
634
+ return second();
635
+ }
636
+ });
637
+ const writeAt = (handle, edit) => guard(async () => {
638
+ const writer = await handle.createWritable({ keepExistingData: true });
639
+ try {
640
+ await edit(writer);
641
+ await writer.close();
642
+ } catch (error) {
643
+ await writer.abort().catch(() => {});
644
+ throw error;
645
+ }
646
+ });
647
+ return {
648
+ root,
649
+ limit: Number.MAX_SAFE_INTEGER,
650
+ type: (node) => node.kind === "file" ? "file" : "directory",
651
+ lookup,
652
+ async create(parent, name, type) {
653
+ const directory = parent;
654
+ if (await optional(directory, name))
655
+ fail("exist", "Entry already exists");
656
+ return guard(() => type === "file" ? directory.getFileHandle(name, { create: true }) : directory.getDirectoryHandle(name, { create: true }));
657
+ },
658
+ retain(node) {
659
+ const result = registry.then(async () => {
660
+ const entry = await canonical(node);
661
+ if (entry) {
662
+ entry.count++;
663
+ return entry.handle;
664
+ }
665
+ retained.set(node.name, [...retained.get(node.name) ?? [], { handle: node, count: 1 }]);
666
+ return node;
667
+ });
668
+ registry = result.catch(() => {});
669
+ return result;
670
+ },
671
+ release(node) {
672
+ const entry = retained.get(node.name)?.find((candidate) => candidate.handle === node);
673
+ if (!entry || --entry.count)
674
+ return;
675
+ (queues.get(node) ?? Promise.resolve()).then(() => {
676
+ const group = retained.get(node.name);
677
+ if (entry.count || !group?.includes(entry))
678
+ return;
679
+ group.splice(group.indexOf(entry), 1);
680
+ if (!group.length)
681
+ retained.delete(node.name);
682
+ });
683
+ },
684
+ stat: (node) => guard(async () => {
685
+ if (node.kind !== "file")
686
+ return { type: "directory", size: 0n };
687
+ const value = await node.getFile();
688
+ return { type: "file", size: BigInt(value.size), modified: value.lastModified };
689
+ }),
690
+ same: (a, b) => guard(() => a.isSameEntry(b)),
691
+ async* entries(node) {
692
+ const iterate = node.entries;
693
+ if (typeof iterate !== "function")
694
+ fail("unsupported", "Directory enumeration is unavailable");
695
+ const source = iterate.call(node);
696
+ try {
697
+ while (true) {
698
+ const step = await guard(() => source.next());
699
+ if (step.done)
700
+ return;
701
+ const [name, handle] = step.value;
702
+ yield { name, type: handle.kind === "file" ? "file" : "directory" };
703
+ }
704
+ } finally {
705
+ await source.return?.();
706
+ }
707
+ },
708
+ read: (node, offset, length) => guard(async () => {
709
+ const value = await node.getFile();
710
+ if (offset >= value.size)
711
+ return new Uint8Array(0);
712
+ return new Uint8Array(await value.slice(offset, offset + length).arrayBuffer());
713
+ }),
714
+ write: (node, offset, data) => serialize(node, async () => {
715
+ const handle = node;
716
+ const position = offset ?? (await guard(() => handle.getFile())).size;
717
+ if (position + data.byteLength > Number.MAX_SAFE_INTEGER)
718
+ fail("file-too-large", "File size limit exceeded");
719
+ await writeAt(handle, (writer) => writer.write({ type: "write", position, data }));
720
+ }),
721
+ writeStream: (node, offset, chunks) => serialize(node, async () => {
722
+ const handle = node;
723
+ let position = offset;
724
+ let writer;
725
+ let failure;
726
+ try {
727
+ for await (const chunk of chunks) {
728
+ position ??= (await guard(() => handle.getFile())).size;
729
+ if (position + chunk.byteLength > Number.MAX_SAFE_INTEGER)
730
+ fail("file-too-large", "File size limit exceeded");
731
+ writer ??= await guard(() => handle.createWritable({ keepExistingData: true }));
732
+ const active = writer;
733
+ const at = position;
734
+ await guard(() => active.write({ type: "write", position: at, data: chunk })).catch(async (error) => {
735
+ writer = undefined;
736
+ await active.abort().catch(() => {});
737
+ throw error;
738
+ });
739
+ position += chunk.byteLength;
740
+ }
741
+ } catch (error) {
742
+ failure = { error };
743
+ }
744
+ if (writer) {
745
+ const active = writer;
746
+ await guard(() => active.close()).catch(async (error) => {
747
+ await active.abort().catch(() => {});
748
+ throw error;
749
+ });
750
+ }
751
+ if (failure)
752
+ throw failure.error;
753
+ }),
754
+ resize: (node, size) => serialize(node, () => writeAt(node, (writer) => writer.truncate(size))),
755
+ sync: async (node) => {
756
+ await queues.get(node);
757
+ },
758
+ async remove(parent, name, type) {
759
+ const directory = parent;
760
+ const node = await lookup(directory, name, type);
761
+ if (node.kind !== (type === "file" ? "file" : "directory"))
762
+ fail(type === "file" ? "is-directory" : "not-directory", "Entry has another type");
763
+ await guard(() => directory.removeEntry(name));
764
+ },
765
+ async rename(fromNode, fromName, toNode, toName) {
766
+ const from = fromNode;
767
+ const to = toNode;
768
+ const source = await lookup(from, fromName);
769
+ const move = source.move;
770
+ if (typeof move !== "function")
771
+ fail("unsupported", "This browser cannot move OPFS entries");
772
+ const replaced = await optional(to, toName);
773
+ if (replaced) {
774
+ if (await guard(() => replaced.isSameEntry(source)))
775
+ return;
776
+ if (source.kind === "file" && replaced.kind === "directory")
777
+ fail("is-directory", "Target is a directory");
778
+ if (source.kind === "directory" && replaced.kind === "file")
779
+ fail("not-directory", "Target is not a directory");
780
+ if (replaced.kind === "directory") {
781
+ const children = replaced.entries?.call(replaced);
782
+ const first = children ? await guard(() => children.next()) : undefined;
783
+ await children?.return?.();
784
+ if (first && !first.done)
785
+ fail("not-empty", "Target directory is not empty");
786
+ fail("unsupported", "Replacing a directory cannot be done atomically in OPFS");
787
+ }
788
+ }
789
+ if (source.kind === "directory") {
790
+ const inside = await guard(() => source.resolve(to));
791
+ if (inside)
792
+ fail("invalid", "Cannot move a directory into itself");
793
+ }
794
+ const entry = await canonical(source);
795
+ const handle = entry?.handle ?? source;
796
+ const previous = handle.name;
797
+ await serialize(handle, () => guard(() => move.call(handle, to, toName), { InvalidModificationError: "unsupported" }));
798
+ if (entry && handle.name !== previous) {
799
+ const group = retained.get(previous) ?? [];
800
+ group.splice(group.indexOf(entry), 1);
801
+ if (!group.length)
802
+ retained.delete(previous);
803
+ retained.set(handle.name, [...retained.get(handle.name) ?? [], entry]);
804
+ }
805
+ }
806
+ };
807
+ }
808
+ async function opfsFilesystem2(directory) {
809
+ return provider(opfsStore(directory));
810
+ }
811
+ // src/interpreter/socket-provider.ts
812
+ class SocketProviderError2 extends Error {
813
+ code;
814
+ constructor(code, message = `socket provider failed: ${code.tag}`) {
815
+ super(message);
816
+ this.code = code;
817
+ this.name = "SocketProviderError";
818
+ }
819
+ }
820
+
821
+ class NameLookupError2 extends Error {
822
+ code;
823
+ constructor(code, message = `name lookup failed: ${code.tag}`) {
824
+ super(message);
825
+ this.code = code;
826
+ this.name = "NameLookupError";
827
+ }
828
+ }
829
+
830
+ export { PREPARED_FORMAT, PREPARED_GENERATOR, PREPARED_MAXIMUM_PAGES, COMPONENT_CORE, TRAMPOLINE_CORE, BrowserPlatformError2, preparedComponent2, preparedRegistry, FilesystemError2, memoryFilesystem2, opfsFilesystem2, SocketProviderError2, NameLookupError2 };