rooklang 0.3.3 → 0.3.4

package/dist/typescript/convert-objects.js

@@ -9,10 +9,13 @@ export class ObjectConverter extends ConverterBase {
             const [element] = checker.getTypeArguments(type);
             return arrayOf(element ? this.convert(element) : ANY);
         }
-        // A tuple is an array of any of its elements: `[string, number]` is `[](string | number)`.
+        // A tuple is an array of any of its elements: `[string, number]` is `[](string | number)`,
+        // which keeps them by position too, to infer the type parameters of `[K, V]`.
         if (checker.isTupleType(type)) {
-            const elements = checker.getTypeArguments(type);
-            return arrayOf(elements.length > 0 ? union(elements.map((each) => this.convert(each))) : ANY);
+            const elements = checker
+                .getTypeArguments(type)
+                .map((each) => this.convert(each));
+            return elements.length > 0 ? arrayOf(union(elements), elements) : arrayOf(ANY);
         }
         if (type.objectFlags & ObjectFlags.Reference) {
             const reference = type;
@@ -116,23 +119,26 @@ export class ObjectConverter extends ConverterBase {
             object.index = this.convert(index);
         if (numberIndex && numberIndex !== index)
             object.numberIndex = this.convert(numberIndex);
-        this.iterates(object, type);
+        this.iterates(object, type, 'iterates');
+        this.iterates(object, type, 'asyncIterates');
         return object;
     }
     /**
      * What `for v in x` gives: the `value` of what `next()` of `[Symbol.iterator]()` returns while
-     * it is not `done`. Found when it is first needed, as most types are never looped over.
+     * it is not `done`, or of what its Promise gives for `[Symbol.asyncIterator]()`. Found when it is
+     * first needed, as most types are never looped over.
      */
-    iterates(object, type) {
+    iterates(object, type, key) {
         const { checker } = this;
+        const prefix = key === 'iterates' ? '__@iterator@' : '__@asyncIterator@';
         const iterator = type
             .getProperties()
-            .find((property) => String(property.escapedName).startsWith('__@iterator@'));
+            .find((property) => String(property.escapedName).startsWith(prefix));
         if (!iterator)
             return;
         let found;
         let done = false;
-        Object.defineProperty(object, 'iterates', {
+        Object.defineProperty(object, key, {
             enumerable: true,
             get: () => {
                 if (done)
@@ -143,7 +149,8 @@ export class ObjectConverter extends ConverterBase {
                     .getCallSignatures()[0]
                     ?.getReturnType()
                     .getProperty('next');
-                const result = next && checker.getTypeOfSymbol(next).getCallSignatures()[0]?.getReturnType();
+                const returned = next && checker.getTypeOfSymbol(next).getCallSignatures()[0]?.getReturnType();
+                const result = returned && key === 'asyncIterates' ? checker.getAwaitedType(returned) : returned;
                 const results = result?.isUnion() ? result.types : result ? [result] : [];
                 const yielded = results.find((each) => {
                     const flag = each.getProperty('done');
@@ -240,6 +247,8 @@ export class ObjectConverter extends ConverterBase {
         if (base)
             info.superClass = this.classInfo(base.symbol);
         info.ctor = this.signatures(checker.getSignaturesOfType(statics, SignatureKind.Construct));
+        // A stream of Node is a class, gone over with `for await` in JS.
+        this.iterates(info, instance, 'asyncIterates');
         return info;
     }
 }

package/dist/vite.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { RUNTIME_MODULE } from "./runtime-module.js";
 import { formatDiagnostic } from "./diagnostics.js";
@@ -12,6 +12,8 @@ import { SourceFile } from "./source.js";
 // path has no query, since Vite drops the query of a worker's URL. The compiled code imports the
 // runtime, "rooklang/runtime", of the plugin's own package.
 const GOROUTINES = '.goroutines.js';
+/** The loader of `.rk` files of `rook run`, next to this file: .ts in src, .js in the package. */
+const LOADER = new URL(`./loader${extname(fileURLToPath(import.meta.url))}`, import.meta.url).href;
 export function rook(options = {}) {
     const typeCheck = options.typeCheck ?? true;
     let root = process.cwd();
@@ -46,7 +48,7 @@ export function rook(options = {}) {
                 return null;
             return readFileSync(path.slice(0, -GOROUTINES.length), 'utf8');
         },
-        transform(source, id) {
+        transform(source, id, transformOptions) {
             const [name = id, query] = id.split('?');
             const worker = name.endsWith(`.rk${GOROUTINES}`);
             const path = worker ? name.slice(0, -GOROUTINES.length) : name;
@@ -59,7 +61,11 @@ export function rook(options = {}) {
                 rewriteImports: false,
                 typeCheck,
                 markup: options.markup,
-                workerUrl: `./${basename(path)}${GOROUTINES}`,
+                // In Node, as under Vitest, a worker thread loads the module itself, `app.rk?goroutines`,
+                // with the loader of `rook run`, which it imports first: it has no Vite.
+                ...(transformOptions?.ssr === true
+                    ? { workerUrl: `./${basename(path)}?goroutines`, nodeLoader: LOADER }
+                    : { workerUrl: `./${basename(path)}${GOROUTINES}` }),
             });
             const file = new SourceFile(relative(root, path), source);
             // Vite counts columns from 0.
@@ -86,7 +92,9 @@ export function rook(options = {}) {
             for (const dependency of result.dependencies) {
                 this.addWatchFile(resolve(dirname(path), dependency));
             }
-            return { code: worker ? (result.worker ?? '') : result.code, map: null };
+            return worker
+                ? { code: result.worker ?? '', map: result.workerMap ?? null }
+                : { code: result.code, map: result.map ?? null };
         },
     };
 }

package/dist/walk-types.js

@@ -19,6 +19,7 @@ export function forEachTypeChild(node, visit) {
         case 'ArrayType':
         case 'ChanType':
         case 'QueueType':
+        case 'TopicType':
             visit(node.element);
             break;
         case 'NullableType':

package/dist/walk.d.ts

@@ -1,5 +1,3 @@
 import type * as ast from './ast.ts';
 /** Calls `visit` for each direct child of `node`, in source order. */
 export declare function forEachChild(node: ast.Node, visit: (child: ast.Node) => void): void;
-/** Whether a `break` in these statements leaves the enclosing loop or switch. */
-export declare function containsBreak(statements: readonly ast.Statement[]): boolean;

package/dist/walk.js

@@ -30,7 +30,7 @@ export function forEachChild(node, visit) {
             visit(node.name);
             each(node.params);
             each(node.results);
-            visit(node.body);
+            optional(node.body);
             break;
         case 'Parameter':
             visit(node.name);
@@ -111,11 +111,16 @@ export function forEachChild(node, visit) {
             visit(node.element);
             optional(node.items);
             break;
+        case 'TopicExpression':
+            visit(node.element);
+            visit(node.name);
+            break;
         case 'MakeExpression':
             visit(node.type);
             visit(node.length);
             break;
         case 'ConversionExpression':
+        case 'DecodeExpression':
             visit(node.type);
             visit(node.argument);
             break;
@@ -123,6 +128,7 @@ export function forEachChild(node, visit) {
             each(node.values);
             break;
         case 'IfStatement':
+            optional(node.init);
             visit(node.condition);
             visit(node.consequent);
             optional(node.alternate);
@@ -140,6 +146,7 @@ export function forEachChild(node, visit) {
             visit(node.body);
             break;
         case 'SwitchStatement':
+            optional(node.init);
             optional(node.discriminant);
             each(node.cases);
             break;
@@ -204,6 +211,7 @@ export function forEachChild(node, visit) {
             visit(node.body);
             break;
         case 'UnaryExpression':
+        case 'TryExpression':
             visit(node.argument);
             break;
         case 'GoExpression':
@@ -265,6 +273,7 @@ export function forEachChild(node, visit) {
         case 'ArrayType':
         case 'ChanType':
         case 'QueueType':
+        case 'TopicType':
         case 'NullableType':
         case 'FuncType':
         case 'ComponentType':
@@ -287,6 +296,7 @@ export function forEachChild(node, visit) {
         case 'NumberLiteral':
         case 'BigIntLiteral':
         case 'StringLiteral':
+        case 'RegExpLiteral':
         case 'TemplateElement':
         case 'BooleanLiteral':
         case 'NullLiteral':
@@ -295,30 +305,3 @@ export function forEachChild(node, visit) {
             break;
     }
 }
-/** Whether a `break` in these statements leaves the enclosing loop or switch. */
-export function containsBreak(statements) {
-    let found = false;
-    const visit = (node) => {
-        switch (node.kind) {
-            case 'BreakStatement':
-                found = true;
-                return;
-            // A `break` inside these belongs to them.
-            case 'ForStatement':
-            case 'ForInStatement':
-            case 'SwitchStatement':
-            case 'SelectStatement':
-            case 'FuncDeclaration':
-            case 'FuncExpression':
-            case 'ArrowFunction':
-            case 'ClassDeclaration':
-            case 'MountStatement':
-            case 'EffectStatement':
-                return;
-            default:
-                forEachChild(node, visit);
-        }
-    };
-    statements.forEach(visit);
-    return found;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rooklang",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "A language with JavaScript semantics, Go-style syntax, goroutines on real threads and static types that compiles to readable JavaScript",
   "keywords": [
     "rooklang",

package/src/runtime/chan.js

@@ -1,10 +1,11 @@
 // Channels: sending, receiving and closing, here or in the thread that made the channel
 // (threads.js), and the queues of a channel. Receiving from a closed channel gives
-// the zero value of its type, as in Go.
+// the zero value of its type, as in Go. Channel.EMPTY is closed and belongs to no thread: a send to
+// it goes nowhere, and receiving gives the zero value that the code that receives passes.
 
 import { $$Queue } from './queue.js';
 import { $$commit, $$lock, $$select, $$try, $$unlock, $$unwait } from './select.js';
-import { $$adopt, $$ask, $$ownerOf, $$post, $$registry, $$stopped } from './threads.js';
+import { $$adopt, $$ask, $$isEmpty, $$ownerOf, $$post, $$registry, $$stopped } from './threads.js';
 
 $$registry().handle ??= { message: $$message, pump: $$pump };
 
@@ -32,6 +33,9 @@ export function $$chan(size, zero) {
 // that made the channel.
 export function $$send(channel, value) {
   const id = channel.$$chan;
+
+  if ($$isEmpty(id)) return Promise.resolve();
+
   const owner = $$ownerOf(id);
 
   if (owner !== $$registry().key) return $$ask(owner, { op: 'send', channel: id, value });
@@ -41,11 +45,12 @@ export function $$send(channel, value) {
   );
 }
 
-export function $$receive(channel, withOk = false) {
+export function $$receive(channel, withOk = false, zero = null) {
   const id = channel.$$chan;
   const owner = $$ownerOf(id);
-  const received =
-    owner !== $$registry().key
+  const received = $$isEmpty(id)
+    ? Promise.resolve([zero, false])
+    : owner !== $$registry().key
       ? $$ask(owner, { op: 'receive', channel: id })
       : new Promise((resolve, reject) => $$wait(id, 'receivers', { done: resolve, fail: reject }));
 
@@ -55,6 +60,9 @@ export function $$receive(channel, withOk = false) {
 // Closing a channel of another thread fails this one if it was closed already, as a panic would.
 export function $$close(channel) {
   const id = channel.$$chan;
+
+  if ($$isEmpty(id)) return;
+
   const owner = $$ownerOf(id);
 
   if (owner === $$registry().key) return $$closeHere(id);
@@ -70,6 +78,8 @@ export function $$closeHere(id) {
 
   if (state.closed) throw new Error('close of a closed channel');
   state.closed = true;
+  // What made the channel stops with it, as signal() does (signals.js).
+  state.onClose?.();
   $$pump(id);
 }
 

package/src/runtime/channel.js

@@ -0,0 +1,28 @@
+// `Channel`: what Rook code and the code compiled from it do with channels, by name. The functions
+// themselves are in chan.js, select.js, signals.js, streams.js and timers.js.
+
+import { $$chan, $$close, $$range, $$receive, $$send } from './chan.js';
+import { $$select, $$try } from './select.js';
+import { $$abortSignal, $$done, $$signal } from './signals.js';
+import { $$fromStream, $$stream } from './streams.js';
+import { $$after, $$tick } from './timers.js';
+
+export const $$Channel = Object.freeze({
+  // The zero value of channel types: closed, and the same in every thread (threads.js).
+  EMPTY: Object.freeze({ $$chan: 'empty', size: 0, zero: null }),
+  make: $$chan,
+  send: $$send,
+  receive: $$receive,
+  close: $$close,
+  range: $$range,
+  select: $$select,
+  // [] for a send and [value, ok] for a receive that goes on at once, else null.
+  try: (channel, send, value) => $$try(channel.$$chan, send, value),
+  fromStream: $$fromStream,
+  stream: $$stream,
+  after: $$after,
+  tick: $$tick,
+  signal: $$signal,
+  done: $$done,
+  abortSignal: $$abortSignal,
+});

package/src/runtime/classes.js

@@ -0,0 +1,32 @@
+// Data classes: `data class Point` registers its class with an id of its own, the name and a hash
+// of its code, the same in a module and in its worker module, which has a copy of the class. A copy
+// of a value that goes to another thread loses the class of its instances (structuredClone); the
+// thread that sends lists them with their ids (threads.js), and the one that gets the copy gives
+// them their class again.
+
+function registry() {
+  return (globalThis[Symbol.for('rook.classes')] ??= { byId: new Map(), ids: new WeakMap() });
+}
+
+export function $$dataClass(cls, id) {
+  const { byId, ids } = registry();
+
+  byId.set(id, cls.prototype);
+  ids.set(cls.prototype, id);
+}
+
+/** The id of the data class of an instance, or undefined. */
+export function $$classOf(value) {
+  return registry().ids.get(Object.getPrototypeOf(value));
+}
+
+/** Gives the copies of instances their classes back: `[object, id]` pairs of a copied message. */
+export function $$reclass(instances) {
+  const { byId } = registry();
+
+  for (const [object, id] of instances) {
+    const prototype = byId.get(id);
+
+    if (prototype) Object.setPrototypeOf(object, prototype);
+  }
+}

package/src/runtime/core.js

@@ -1,4 +1,5 @@
-// What the code of any module may need: `for` over a value of unknown type, and `defer`.
+// What the code of any module may need: `for` over a value of unknown type, `defer`, and wrapped
+// errors.
 
 // `for v in x` over an untyped value: a Map gives its values, as a typed one does.
 export function $$values(iterable) {
@@ -21,3 +22,11 @@ export function $$runDeferred(deferred) {
 
   if (failure) throw failure.error;
 }
+
+// `error("load user", err)`: an error whose message ends with that of its cause, as `%w` of Go
+// gives "load user: not found", and whose `cause` is the error itself, for code that looks at it.
+export function $$wrap(message, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+
+  return new Error(`${message}: ${reason}`, { cause });
+}

package/src/runtime/decode.js

@@ -0,0 +1,190 @@
+// `decode<T>(x)`: JSON text, or a value from JS, checked against the type T, which the compiler
+// writes as data: "number", "string", "bool", "any", { literal: [values] }, { nullable: T },
+// { array: T }, { record: T }, { union: [types] } and $$type(name, fields) for an object. A value
+// that fits is returned as it is, with the fields that T does not have; a nullable field may be
+// missing. The error says where the value does not fit: `decode User: tags[1]: expected string,
+// got 42`.
+
+/** An object type. Its fields come from a function, so that types can refer to each other. */
+export function $$type(name, fields) {
+  let resolved = null;
+
+  return {
+    name,
+    get fields() {
+      return (resolved ??= fields());
+    },
+  };
+}
+
+/** `decode<T>(text)` of a string: the JSON text is parsed, then checked. */
+export function $$decodeJson(text, type) {
+  let value;
+
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    return [null, new Error(`decode ${describe(type)}: invalid JSON: ${error.message}`)];
+  }
+
+  return $$decode(value, type);
+}
+
+/**
+ * `decode<T>(value)` of a value from JS. Without the types of the checker (`rook build --no-check`)
+ * the type is null: then a string is parsed as JSON text, and nothing is checked.
+ */
+export function $$decode(value, type) {
+  if (type === null) return typeof value === 'string' ? $$decodeJson(value, 'any') : [value, null];
+
+  const problem = check(value, type, []);
+
+  if (problem === null) return [value, null];
+
+  const where = problem.path.length > 0 ? `${pathText(problem.path)}: ` : '';
+
+  return [null, new Error(`decode ${describe(type)}: ${where}${problem.message}`)];
+}
+
+const PRIMITIVES = { number: 'number', string: 'string', bool: 'boolean' };
+
+/** Where and how the value does not fit the type, or null if it does. */
+function check(value, type, path) {
+  if (typeof type === 'string') {
+    return type === 'any' || typeof value === PRIMITIVES[type] ? null : mismatch(value, type, path);
+  }
+
+  if ('literal' in type) return type.literal.includes(value) ? null : mismatch(value, type, path);
+
+  if ('nullable' in type) {
+    if (value == null) return null;
+
+    const problem = check(value, type.nullable, path);
+
+    // The value itself is of another type: the message names ?T, not T.
+    return problem !== null && problem.path.length === path.length
+      ? mismatch(value, type, path)
+      : problem;
+  }
+
+  if ('array' in type) {
+    if (!Array.isArray(value)) return mismatch(value, type, path);
+
+    for (let i = 0; i < value.length; i++) {
+      const problem = check(value[i], type.array, [...path, i]);
+
+      if (problem !== null) return problem;
+    }
+
+    return null;
+  }
+
+  if ('union' in type) return checkUnion(value, type, path);
+  if (!isObject(value)) return mismatch(value, type, path);
+
+  if ('record' in type) {
+    for (const key of Object.keys(value)) {
+      const problem = check(value[key], type.record, [...path, key]);
+
+      if (problem !== null) return problem;
+    }
+
+    return null;
+  }
+
+  for (const [name, field] of Object.entries(type.fields)) {
+    // Only own fields: a field named `toString` is not the method of every object.
+    if (!Object.hasOwn(value, name)) {
+      if (isOptional(field)) continue;
+
+      return { path: [...path, name], message: 'missing' };
+    }
+
+    const problem = check(value[name], field, [...path, name]);
+
+    if (problem !== null) return problem;
+  }
+
+  return null;
+}
+
+/**
+ * The value fits one of the types. If none fits, the type whose check went deepest into the value
+ * is most likely the one meant, `{ kind: "circle", r: "2" }` of `Circle | Square`, so its problem
+ * is the one reported.
+ */
+function checkUnion(value, type, path) {
+  let deepest = null;
+
+  for (const member of type.union) {
+    const problem = check(value, member, path);
+
+    if (problem === null) return null;
+    if (problem.path.length > (deepest?.path.length ?? path.length)) deepest = problem;
+  }
+
+  return deepest ?? mismatch(value, type, path);
+}
+
+function isObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isOptional(type) {
+  return type === 'any' || (typeof type === 'object' && 'nullable' in type);
+}
+
+function mismatch(value, type, path) {
+  return { path, message: `expected ${describe(type)}, got ${shown(value)}` };
+}
+
+/** The type as Rook writes it: `[]string`, `?User`, `"admin" | "user"`. */
+function describe(type) {
+  if (typeof type === 'string') return type;
+  if ('literal' in type) return type.literal.map((value) => JSON.stringify(value)).join(' | ');
+  if ('nullable' in type) return `?${grouped(type.nullable)}`;
+  if ('array' in type) return `[]${grouped(type.array)}`;
+  if ('record' in type) return `{ [key string]: ${describe(type.record)} }`;
+  if ('union' in type) return type.union.map(describe).join(' | ');
+
+  return type.name;
+}
+
+function grouped(type) {
+  const several = typeof type === 'object' && ('union' in type || type.literal?.length > 1);
+
+  return several ? `(${describe(type)})` : describe(type);
+}
+
+/** The value in a message: a primitive itself, a long string cut, and the kind of anything else. */
+function shown(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'an array';
+
+  switch (typeof value) {
+    case 'string':
+      return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
+
+    case 'number':
+    case 'boolean':
+      return String(value);
+
+    case 'object':
+      return 'an object';
+
+    default:
+      return typeof value;
+  }
+}
+
+/** `tags[1]`, `boss.name`, `["first name"]`. */
+function pathText(path) {
+  return path
+    .map((key, i) => {
+      if (typeof key === 'number') return `[${key}]`;
+      if (/^[A-Za-z_$][\w$]*$/.test(key)) return i === 0 ? key : `.${key}`;
+
+      return `[${JSON.stringify(key)}]`;
+    })
+    .join('');
+}

package/src/runtime/go.js

@@ -9,6 +9,7 @@ import {
   $$gone,
   $$incoming,
   $$post,
+  $$reclassed,
   $$registry,
   $$transfer,
 } from './threads.js';
@@ -142,6 +143,7 @@ export function $$pool() {
       worker.owns = data.owns;
     } else if ('returned' in data) {
       $$adopt(data);
+      $$reclassed(data);
 
       const call = calls.get(data.returned);
 
@@ -311,6 +313,7 @@ export async function $$serve(functions) {
     if ('gone' in data) return $$gone(data.gone);
     setTimeout(free);
     $$adopt(data.args);
+    $$reclassed(data);
 
     const { main } = registry;
 

package/src/runtime/index.js

@@ -3,11 +3,17 @@
 // The compiler can also put the parts that a module needs into the module itself (runtime.ts).
 
 export * from './chan.js';
+export * from './channel.js';
+export * from './classes.js';
 export * from './core.js';
+export * from './decode.js';
 export * from './go.js';
 export * from './markup.js';
 export * from './queue.js';
 export * from './select.js';
+export * from './signals.js';
 export * from './streams.js';
 export * from './threads.js';
 export * from './timers.js';
+export * from './topic.js';
+export * from './try.js';

package/src/runtime/select.js

@@ -3,12 +3,13 @@
 // channels of a select.
 
 import { $$finish, $$pump, $$zero } from './chan.js';
-import { $$ask, $$ownerOf, $$pin, $$post, $$registry, $$stopped } from './threads.js';
+import { $$ask, $$isEmpty, $$ownerOf, $$pin, $$post, $$registry, $$stopped } from './threads.js';
 
 // `select`: the index of the case that went on, and what it received. A case is { channel } to
-// receive or { channel, value } to send; from another thread, { channel, send, value }. One that
-// can go on at once wins, a random one as in Go; else `default`, -1, if there is one; else the
-// first that can go on later. A case with a null channel never goes on.
+// receive or { channel, value } to send, with the zero value that Channel.EMPTY gives, if it is
+// not null; from another thread, { channel, send, value }. One that can go on at once wins, a
+// random one as in Go; else `default`, -1, if there is one; else the first that can go on later.
+// A case with a null channel never goes on, and one with Channel.EMPTY always can.
 export async function $$select(cases, hasDefault) {
   const registry = $$registry();
   const all = cases.map((each, i) => ({
@@ -16,12 +17,13 @@ export async function $$select(cases, hasDefault) {
     id: typeof each.channel === 'string' ? each.channel : (each.channel?.$$chan ?? null),
     send: each.send ?? 'value' in each,
     value: each.value,
+    zero: each.zero ?? null,
   }));
   const live = all.filter(({ id }) => id !== null);
-  const owners = new Set(live.map(({ id }) => $$ownerOf(id)));
+  const owners = new Set(live.filter(({ id }) => !$$isEmpty(id)).map(({ id }) => $$ownerOf(id)));
 
   // The channels of one other thread: the select runs there.
-  if (owners.size === 1 && !owners.has(registry.key)) {
+  if (owners.size === 1 && !owners.has(registry.key) && live.every(({ id }) => !$$isEmpty(id))) {
     const [owner] = owners;
 
     return $$ask(owner, {
@@ -34,10 +36,13 @@ export async function $$select(cases, hasDefault) {
   const order = live.map(({ i }) => i).sort(() => Math.random() - 0.5);
 
   for (const i of order) {
-    const { id, send, value } = all[i];
+    const { id, send, value, zero } = all[i];
     const owner = $$ownerOf(id);
-    const ready =
-      owner === registry.key
+    const ready = $$isEmpty(id)
+      ? send
+        ? []
+        : [zero, false]
+      : owner === registry.key
         ? $$try(id, send, value)
         : await $$ask(owner, { op: 'try', channel: id, send, value });