@opencode/codemode 0.0.0-dev-19566 → 0.0.0-dev-19568

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.
@@ -1,8 +1,8 @@
1
1
  import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
2
- import { InterpreterRuntimeError, ProgramThrow } from "./model.js";
2
+ import { CallSite, ProgramThrow, typeError } from "./model.js";
3
3
  import { Callable, define, get, hidden, ProgramArray, ProgramFunction, ProgramObject, ProgramPromise, record, } from "./objects.js";
4
4
  import { constructor, fn, methods, native, receiver, requiresNew } from "./native.js";
5
- import { caughtErrorValue, createAggregateErrorValue, normalizeError } from "./errors.js";
5
+ import { createAggregateErrorValue, locate, materialize, normalizeError } from "./errors.js";
6
6
  import { typeofValue } from "./references.js";
7
7
  import { applyCollectionCallback, isSupportedCallback } from "./runner.js";
8
8
  // A `resolve`/`reject` handed to an executor or thenable: calling it settles the capability.
@@ -32,10 +32,11 @@ export class PromiseRuntime {
32
32
  });
33
33
  }
34
34
  create(effect) {
35
- return Effect.suspend(() => {
35
+ return Effect.flatMap(CallSite, (site) => {
36
36
  // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
37
37
  const id = this.nextID++;
38
- return Effect.map(Effect.forkIn(effect, this.scope, { startImmediately: true }), (fiber) => {
38
+ const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site)));
39
+ return Effect.map(Effect.forkIn(body, this.scope, { startImmediately: true }), (fiber) => {
39
40
  const promise = new ProgramPromise(this.proto, fiber);
40
41
  this.active.add(promise);
41
42
  this.ids.set(promise, id);
@@ -83,10 +84,10 @@ export class PromiseRuntime {
83
84
  });
84
85
  }
85
86
  }
86
- export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node);
87
- export const resolvePromiseValue = (runner, value, node, own) => {
88
- if (own?.promise !== undefined && value === own.promise)
89
- return Effect.fail(selfResolutionError(node));
87
+ export const resolvePromiseValue = (runner, value, own) => {
88
+ if (own?.promise !== undefined && value === own.promise) {
89
+ return Effect.die(typeError("Chaining cycle detected: a promise cannot resolve with itself."));
90
+ }
90
91
  if (value instanceof ProgramPromise)
91
92
  return runner.settlePromise(value);
92
93
  if (!(value instanceof ProgramObject))
@@ -100,39 +101,38 @@ export const resolvePromiseValue = (runner, value, node, own) => {
100
101
  const deferred = Deferred.makeUnsafe();
101
102
  const resolve = capability(runner, "resolve", (result) => Deferred.doneUnsafe(deferred, Exit.succeed(result)));
102
103
  const reject = capability(runner, "reject", (reason) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason))));
103
- const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject], node));
104
+ const executed = yield* Effect.exit(runner.invokeCallable(then, value, [resolve, reject]));
104
105
  if (!Exit.isSuccess(executed)) {
105
106
  if (Cause.hasInterruptsOnly(executed.cause))
106
107
  return yield* Effect.failCause(executed.cause);
107
108
  Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
108
109
  }
109
- return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), node, own);
110
+ return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), own);
110
111
  });
111
112
  };
112
- export const resolvePromise = (runner, promises, value, node) => {
113
+ export const resolvePromise = (runner, promises, value) => {
113
114
  if (value instanceof ProgramPromise)
114
115
  return Effect.succeed(value);
115
- return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
116
+ return promises.createWithSelf((self) => resolvePromiseValue(runner, value, self));
116
117
  };
117
118
  const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
118
- const invokePromiseMethod = (runner, promises, name, args, node) => {
119
+ const invokePromiseMethod = (runner, promises, name, args) => {
119
120
  if (name === "resolve") {
120
- return resolvePromise(runner, promises, args[0], node);
121
+ return resolvePromise(runner, promises, args[0]);
121
122
  }
122
123
  if (name === "reject") {
123
124
  return promises.create(Effect.fail(new ProgramThrow(args[0])));
124
125
  }
125
126
  return promises.create(Effect.gen(function* () {
126
- const cursor = yield* runner.syncIterator(args[0], node);
127
- if (cursor === undefined) {
128
- throw new InterpreterRuntimeError(`Promise.${name} expects an array or other synchronous iterable.`, node);
129
- }
127
+ const cursor = yield* runner.syncIterator(args[0]);
128
+ if (cursor === undefined)
129
+ throw typeError(`Promise.${name} expects an array or other synchronous iterable.`);
130
130
  const items = [];
131
131
  while (true) {
132
132
  const step = yield* cursor.next;
133
133
  if (step.done)
134
134
  break;
135
- const item = yield* resolvePromise(runner, promises, step.value, node);
135
+ const item = yield* resolvePromise(runner, promises, step.value);
136
136
  promises.markObserved(item);
137
137
  items.push(item);
138
138
  }
@@ -151,7 +151,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
151
151
  return yield* Effect.failCause(exit.cause);
152
152
  outcomes.push(record(runner.prototypes.Object, {
153
153
  status: "rejected",
154
- reason: caughtErrorValue(runner, Cause.squash(exit.cause)),
154
+ reason: materialize(runner, Cause.squash(exit.cause)),
155
155
  }));
156
156
  }
157
157
  yield* Effect.yieldNow;
@@ -159,7 +159,7 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
159
159
  }
160
160
  if (name === "race") {
161
161
  if (items.length === 0) {
162
- throw new InterpreterRuntimeError("Promise.race([]) would never settle; provide at least one promise or value.", node);
162
+ throw typeError("Promise.race([]) would never settle; provide at least one promise or value.");
163
163
  }
164
164
  return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))));
165
165
  }
@@ -168,32 +168,32 @@ const invokePromiseMethod = (runner, promises, name, args, node) => {
168
168
  return Effect.fail(new PromiseAnyFulfilled(exit.value));
169
169
  if (Cause.hasInterruptsOnly(exit.cause))
170
170
  return Effect.failCause(exit.cause);
171
- return Effect.succeed(caughtErrorValue(runner, Cause.squash(exit.cause)));
171
+ return Effect.succeed(materialize(runner, Cause.squash(exit.cause)));
172
172
  }));
173
173
  return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(runner, reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
174
174
  }));
175
175
  };
176
- const instanceMethod = (runner, promises, name, thisValue, args, node) => {
176
+ const instanceMethod = (runner, promises, name, thisValue, args) => {
177
177
  const method = `Promise.prototype.${name}`;
178
- const promise = receiver(ProgramPromise, thisValue, method, node);
178
+ const promise = receiver(ProgramPromise, thisValue, method);
179
179
  promises.markObserved(promise);
180
180
  if (name === "finally") {
181
- return chainFinally(runner, promises, promise, reactionHandler(args[0], method, node), method, node);
181
+ return chainFinally(runner, promises, promise, reactionHandler(args[0], method), method);
182
182
  }
183
- const onFulfilled = name === "then" ? reactionHandler(args[0], method, node) : undefined;
184
- const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method, node);
185
- return chainReaction(runner, promises, promise, onFulfilled, onRejected, method, node);
183
+ const onFulfilled = name === "then" ? reactionHandler(args[0], method) : undefined;
184
+ const onRejected = reactionHandler(name === "then" ? args[1] : args[0], method);
185
+ return chainReaction(runner, promises, promise, onFulfilled, onRejected, method);
186
186
  };
187
- const constructPromise = (runner, promises, executor, node) => {
187
+ const constructPromise = (runner, promises, executor) => {
188
188
  if (!(executor instanceof ProgramFunction)) {
189
- throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node);
189
+ throw typeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).");
190
190
  }
191
191
  return Effect.gen(function* () {
192
192
  const deferred = Deferred.makeUnsafe();
193
- const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, self)));
193
+ const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, self)));
194
194
  const resolve = capability(runner, "resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
195
195
  const reject = capability(runner, "reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
196
- const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject], node));
196
+ const executed = yield* Effect.exit(runner.invokeCallable(executor, undefined, [resolve, reject]));
197
197
  if (!Exit.isSuccess(executed)) {
198
198
  if (Cause.hasInterruptsOnly(executed.cause))
199
199
  return yield* Effect.failCause(executed.cause);
@@ -210,11 +210,11 @@ class PromiseAnyFulfilled {
210
210
  this.value = value;
211
211
  }
212
212
  }
213
- const reactionHandler = (value, method, node) => {
213
+ const reactionHandler = (value, method) => {
214
214
  if (isSupportedCallback(value))
215
215
  return value;
216
216
  if (typeofValue(value) === "function") {
217
- throw new InterpreterRuntimeError(`${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
217
+ throw typeError(`${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`);
218
218
  }
219
219
  return undefined;
220
220
  };
@@ -226,23 +226,23 @@ const reactionExit = (promises, source) => Effect.gen(function* () {
226
226
  yield* Effect.yieldNow;
227
227
  return exit;
228
228
  });
229
- const chainReaction = (runner, promises, source, onFulfilled, onRejected, method, node) => {
229
+ const chainReaction = (runner, promises, source, onFulfilled, onRejected, method) => {
230
230
  return promises.createWithSelf((self) => Effect.gen(function* () {
231
231
  const exit = yield* reactionExit(promises, source);
232
232
  const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
233
233
  if (handler === undefined)
234
234
  return yield* exit;
235
- const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(runner, Cause.squash(exit.cause));
236
- const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
237
- return yield* resolvePromiseValue(runner, result, node, self);
235
+ const input = Exit.isSuccess(exit) ? exit.value : materialize(runner, Cause.squash(exit.cause));
236
+ const result = yield* applyCollectionCallback(runner, handler, method)([input]);
237
+ return yield* resolvePromiseValue(runner, result, self);
238
238
  }));
239
239
  };
240
- const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
240
+ const chainFinally = (runner, promises, source, cleanup, method) => promises.create(Effect.gen(function* () {
241
241
  const exit = yield* reactionExit(promises, source);
242
242
  if (cleanup !== undefined) {
243
- const result = yield* applyCollectionCallback(runner, cleanup, method, node)([]);
243
+ const result = yield* applyCollectionCallback(runner, cleanup, method)([]);
244
244
  const intermediate = yield* promises.create(Effect.gen(function* () {
245
- yield* runner.settlePromise(yield* resolvePromise(runner, promises, result, node));
245
+ yield* runner.settlePromise(yield* resolvePromise(runner, promises, result));
246
246
  return yield* exit;
247
247
  }));
248
248
  return yield* runner.settlePromise(intermediate);
@@ -256,21 +256,21 @@ export const promiseGlobal = (runner, promises) => {
256
256
  name: "Promise",
257
257
  length: 1,
258
258
  call: requiresNew("Promise"),
259
- construct: (args, _, node) => constructPromise(runner, promises, args[0], node),
259
+ construct: (args) => constructPromise(runner, promises, args[0]),
260
260
  });
261
261
  // Combinators are not callbacks: `[p].map(Promise.resolve)` must ask for an arrow function.
262
262
  for (const name of promiseStatics) {
263
263
  define(promise, name, native(protos, {
264
264
  name,
265
265
  length: 1,
266
- call: (_, args, node) => invokePromiseMethod(runner, promises, name, args, node),
266
+ call: (_, args) => invokePromiseMethod(runner, promises, name, args),
267
267
  callback: false,
268
268
  }), hidden);
269
269
  }
270
270
  methods(protos, proto, [
271
- ["then", 2, (thisValue, args, node) => instanceMethod(runner, promises, "then", thisValue, args, node)],
272
- ["catch", 1, (thisValue, args, node) => instanceMethod(runner, promises, "catch", thisValue, args, node)],
273
- ["finally", 1, (thisValue, args, node) => instanceMethod(runner, promises, "finally", thisValue, args, node)],
271
+ ["then", 2, (thisValue, args) => instanceMethod(runner, promises, "then", thisValue, args)],
272
+ ["catch", 1, (thisValue, args) => instanceMethod(runner, promises, "catch", thisValue, args)],
273
+ ["finally", 1, (thisValue, args) => instanceMethod(runner, promises, "finally", thisValue, args)],
274
274
  ]);
275
275
  return promise;
276
276
  };
@@ -1,8 +1,7 @@
1
- import { type AstNode } from "./model.js";
2
1
  /** Values that cannot cross the data boundary. */
3
2
  export declare const isRuntimeReference: (value: unknown) => boolean;
4
3
  export declare const containsRuntimeReference: (value: unknown) => boolean;
5
4
  export declare const containsOpaqueReference: (value: unknown) => boolean;
6
- export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, node: AstNode, seen?: Set<object>) => void;
5
+ export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, seen?: Set<object>) => void;
7
6
  export declare const describeValue: (value: unknown) => string;
8
7
  export declare const typeofValue: (value: unknown) => string;
@@ -1,5 +1,5 @@
1
1
  import { ToolReference } from "../tool-runtime.js";
2
- import { InterpreterRuntimeError } from "./model.js";
2
+ import { invalidData } from "./model.js";
3
3
  import { Callable, getOwn, isWrapper, ownKeys, ProgramArray, ProgramDate, ProgramGenerator, ProgramMap, ProgramObject, ProgramPromise, ProgramRegExp, ProgramSet, ProgramURL, ProgramURLSearchParams, } from "./objects.js";
4
4
  /** Values that cannot cross the data boundary. */
5
5
  export const isRuntimeReference = (value) => value instanceof Callable ||
@@ -37,9 +37,9 @@ export const containsRuntimeReference = (value) => find(value, isRuntimeReferenc
37
37
  // Wrapper values are data here, not opaque interpreter references.
38
38
  export const containsOpaqueReference = (value) => find(value, (current) => !isWrapper(current) && isRuntimeReference(current), isWrapper, new Set());
39
39
  // Reject cycles before mutation so later boundary walks remain safe.
40
- export const rejectCircularInsertion = (container, value, label, node, seen = new Set()) => {
40
+ export const rejectCircularInsertion = (container, value, label, seen = new Set()) => {
41
41
  if (find(value, (current) => current === container, isRuntimeReference, seen)) {
42
- throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
42
+ throw invalidData(`${label} contains a circular value.`);
43
43
  }
44
44
  };
45
45
  export const describeValue = (value) => {
@@ -1,6 +1,5 @@
1
1
  import { Effect } from "effect";
2
2
  import type { Prototypes } from "./intrinsics.js";
3
- import { type AstNode } from "./model.js";
4
3
  import { Callable, ProgramPromise } from "./objects.js";
5
4
  export type IteratorCursor<R> = {
6
5
  readonly next: Effect.Effect<{
@@ -11,9 +10,9 @@ export type IteratorCursor<R> = {
11
10
  };
12
11
  /** Everything a native function needs from the realm: calling back into the program and its intrinsic objects. */
13
12
  export type Runner<R> = {
14
- readonly invokeCallable: (callable: unknown, thisValue: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
13
+ readonly invokeCallable: (callable: unknown, thisValue: unknown, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
15
14
  readonly settlePromise: (promise: ProgramPromise) => Effect.Effect<unknown, unknown, never>;
16
- readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
15
+ readonly syncIterator: (value: unknown) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
17
16
  readonly prototypes: Prototypes;
18
17
  };
19
18
  export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
@@ -21,8 +20,8 @@ export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, ef
21
20
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
22
21
  * default hint as "string", like their `Symbol.toPrimitive`.
23
22
  */
24
- export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string" | "default", node: AstNode) => Effect.Effect<unknown, unknown, R>;
25
- export declare const toPrimitiveString: <R>(runner: Runner<R>, value: unknown, node: AstNode) => Effect.Effect<string, unknown, R>;
26
- export declare const toPrimitiveNumber: <R>(runner: Runner<R>, value: unknown, node: AstNode) => Effect.Effect<number, unknown, R>;
23
+ export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string" | "default") => Effect.Effect<unknown, unknown, R>;
24
+ export declare const toPrimitiveString: <R>(runner: Runner<R>, value: unknown) => Effect.Effect<string, unknown, R>;
25
+ export declare const toPrimitiveNumber: <R>(runner: Runner<R>, value: unknown) => Effect.Effect<number, unknown, R>;
27
26
  export declare const isSupportedCallback: (value: unknown) => value is Callable;
28
- export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);
27
+ export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);
@@ -1,6 +1,6 @@
1
1
  import { Effect, Exit } from "effect";
2
2
  import { coerceToNumber, coerceToString } from "../stdlib/value.js";
3
- import { InterpreterRuntimeError } from "./model.js";
3
+ import { typeError } from "./model.js";
4
4
  import { Callable, get, NativeFunction, ProgramDate, ProgramObject, ProgramPromise } from "./objects.js";
5
5
  import { typeofValue } from "./references.js";
6
6
  export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
@@ -10,7 +10,7 @@ export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.e
10
10
  * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
11
11
  * default hint as "string", like their `Symbol.toPrimitive`.
12
12
  */
13
- export const toPrimitive = (runner, value, hint, node) => {
13
+ export const toPrimitive = (runner, value, hint) => {
14
14
  if (!(value instanceof ProgramObject))
15
15
  return Effect.succeed(value);
16
16
  const asString = hint === "string" || (hint === "default" && value instanceof ProgramDate);
@@ -20,26 +20,26 @@ export const toPrimitive = (runner, value, hint, node) => {
20
20
  const callable = get(value, method);
21
21
  if (!(callable instanceof Callable))
22
22
  continue;
23
- const result = yield* runner.invokeCallable(callable, value, [], node);
23
+ const result = yield* runner.invokeCallable(callable, value, []);
24
24
  if (result === null || (typeof result !== "object" && typeof result !== "function"))
25
25
  return result;
26
26
  }
27
- throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node);
27
+ throw typeError("Cannot convert object to primitive value.");
28
28
  });
29
29
  };
30
- export const toPrimitiveString = (runner, value, node) => Effect.map(toPrimitive(runner, value, "string", node), coerceToString);
31
- export const toPrimitiveNumber = (runner, value, node) => Effect.map(toPrimitive(runner, value, "number", node), coerceToNumber);
30
+ export const toPrimitiveString = (runner, value) => Effect.map(toPrimitive(runner, value, "string"), coerceToString);
31
+ export const toPrimitiveNumber = (runner, value) => Effect.map(toPrimitive(runner, value, "number"), coerceToNumber);
32
32
  // The single acceptance list for callbacks: collections, sort, string replacers,
33
33
  // Array.from mappers, and promise reactions all admit exactly these callables.
34
34
  // Admission means dispatchable, not necessarily invocable: new-requiring
35
35
  // constructors pass the gate and throw a TypeError on call, like JS.
36
36
  export const isSupportedCallback = (value) => value instanceof Callable && !(value instanceof NativeFunction && !value.callback);
37
- export const applyCollectionCallback = (runner, callback, name, node) => {
37
+ export const applyCollectionCallback = (runner, callback, name) => {
38
38
  if (!isSupportedCallback(callback)) {
39
39
  if (typeofValue(callback) === "function") {
40
- throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
40
+ throw typeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`);
41
41
  }
42
- throw new InterpreterRuntimeError(`${name} expects a function callback.`, node);
42
+ throw typeError(`${name} expects a function callback.`);
43
43
  }
44
- return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs, node);
44
+ return (callbackArgs) => runner.invokeCallable(callback, undefined, callbackArgs);
45
45
  };