sendscript 0.1.4 → 1.0.1

package/CHANGELOG.md

@@ -4,8 +4,22 @@ All notable changes to this project will be documented in this file. Dates are d
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
+#### [v1.0.1](https://github.com/bas080/sendscript/compare/v1.0.0...v1.0.1)
+
+- Add async await section to readme [`7e56024`](https://github.com/bas080/sendscript/commit/7e560246e2a7b5b34f1de0ce5eb0df62897cc454)
+
+### [v1.0.0](https://github.com/bas080/sendscript/compare/v0.1.4...v1.0.0)
+
+> 3 May 2025
+
+- Add support for async await [`e949184`](https://github.com/bas080/sendscript/commit/e949184ab31a3bfdf4c6181463dcdd7250aca3a8)
+- Update tap to latest version on 2024-03-17 [`1164994`](https://github.com/bas080/sendscript/commit/11649947737ffd152ac46d1db01946ad0c1261e7)
+- Support nested objects and keywords as first item [`06da388`](https://github.com/bas080/sendscript/commit/06da3887c05ab0c545a53b6e796d2f7d4c53e6e6)
+
 #### [v0.1.4](https://github.com/bas080/sendscript/compare/v0.1.3...v0.1.4)
 
+> 8 March 2024
+
 - Add missing index file that exports both modules [`38054ea`](https://github.com/bas080/sendscript/commit/38054ea8284a1626146bec42309b3c014527ff7d)
 - Prevent ref of non existant property on env object [`49520ad`](https://github.com/bas080/sendscript/commit/49520ad32604683c668d95e479de772a91f6ae2b)
 

package/README.md

@@ -13,15 +13,14 @@ Write JS code that you can run on servers, browsers or other clients.
   * [Module](#module)
   * [Server](#server)
   * [Client](#client)
-- [Reference](#reference)
-  * [`sendscript/api.mjs`](#sendscriptapimjs)
-  * [`sendscript/exec.mjs`](#sendscriptexecmjs)
+- [Async/Await](#asyncawait)
 - [TypeScript](#typescript)
 - [Tests](#tests)
 - [Formatting](#formatting)
 - [Changelog](#changelog)
 - [Dependencies](#dependencies)
 - [License](#license)
+- [Roadmap](#roadmap)
 
 <!-- tocstop -->
 
@@ -58,16 +57,17 @@ Here a socket.io server that runs SendScript programs.
 // ./example/server.socket.io.mjs
 
 import { Server } from 'socket.io'
-import exec from '../exec.mjs'
+import Parse from '../parse.mjs'
 import * as math from './math.mjs'
 
+const parse = Parse(math)
 const server = new Server()
 const port = process.env.PORT || 3000
 
 server.on('connection', (socket) => {
   socket.on('message', async (program, callback) => {
     try {
-      const result = await exec(math, program)
+      const result = parse(program)
       callback(null, result) // Pass null as the first argument to indicate success
     } catch (error) {
       callback(error) // Pass the error to the callback
@@ -87,14 +87,17 @@ Now for a client that sends a program to the server.
 // ./example/client.socket.io.mjs
 
 import socketClient from 'socket.io-client'
-import api from '../api.mjs'
+import stringify from '../stringify.mjs'
+import module from '../module.mjs'
+import * as math from './math.mjs'
+import assert from 'node:assert'
 
 const port = process.env.PORT || 3000
 const client = socketClient(`http://localhost:${port}`)
 
-const exec = program => {
+const send = program => {
   return new Promise((resolve, reject) => {
-    client.emit('message', program, (error, result) => {
+    client.emit('message', stringify(program), (error, result) => {
       error
         ? reject(error)
         : resolve(result)
@@ -102,11 +105,16 @@ const exec = program => {
   })
 }
 
-const { add, square } = api(['add', 'square'], exec)
+const { add, square } = module(math)
+
+// The program to be sent over the wire
+const program = square(add(1, add(add(2, 3), 4)))
+
+const result = await send(program)
+
+console.log('Result: ', result)
 
-console.log(
-  await square(add(1, add(add(2, 3), 4)))
-)
+assert.equal(result, 100)
 
 process.exit(0)
 ```
@@ -114,6 +122,8 @@ process.exit(0)
 Now we run this server and a client script.
 
 ```bash
+set -e
+
 # Run the server
 node ./example/server.socket.io.mjs&
 
@@ -123,102 +133,54 @@ node ./example/client.socket.io.mjs
 pkill sendscript
 ```
 ```
-100
+Result:  100
 ```
 
-## Reference
-
-SendScript is essentially a way to serialize a program to then send over the
-wire and execute it somewhere else.
-
-We only have two modules. One that helps you write programs that can be sent
-over the wire and another for running that program.
+## Async/Await
 
-### `sendscript/api.mjs`
+SendScript supports async/await seamlessly within a single request. This avoids the performance pitfalls of waterfall-style messaging, which can be especially slow on high-latency networks.
 
-The api module exports a function that takes two arguments.
-
-1. The schema, which represents the values that are available.
-2. The function that will be called with the serializable version of the
-   program.
-
-It returns an object that contains functions which are defined in the schema.
-These functions are a JavaScript API for writing programs that can be sent to
-a server.
+While it's possible to chain promises manually or use utility functions, native async/await support makes your code more readable, modern, and easier to reason about — aligning SendScript with today’s JavaScript best practices.
 
 ```js
-import api from './api.mjs'
-
-const  { add, subtract } = api(
-  ['add', 'subtract'],
-  serializableProgram => sendSomewhereToBeExecuted(serializableProgram)
-)
-
-await add(1, 2) // => 3
-await subtract(1, 2) // => -1
-await add(1, subtract(2, 3)) // => 0
-```
-
-The add and subtract functions are thennable. The execute function is called as
-soon as await or `.then` is used.
-
-> Notice that you do not have to await the subtract call. You only need to
-> await when you want to execute the program.
-
-This API is composable and wrappable.
-
-### `sendscript/exec.mjs`
-
-The exec function takes an environment object and any valid SendScript program.
-
-```js
-import exec from './exec.mjs'
+const userId = 'user-123'
+const program = {
+  unread: await fetchUnreadMessages(userId),
+  emptyTrash: await emptyTrash(userId),
+  archived: await archiveMessages(selectMessages({ old: true }))
+}
 
-exec({
-  add: (a, b) => a + b,
-  subtract: (a, b) => a - b
-}, ['add', 1, [subtract, 1, 2]])
+const result = await send(program)
 ```
 
-The array you see here is the LISP that SendScript uses to represent programs.
-
-You could use SendScript without knowing the details of how the LISP works. It
-is an implementation detail and might change over time.
+This operation is done in a single round-trip. The result is an object with the defined properties and returned values.
 
 ## TypeScript
 
-There is a good use-case to write an environment module in TypeScript.
+There is a good use-case to write a module in TypeScript.
 
 1. Obviously the module would have the benefits that TypeScript offers when
    coding.
 2. You can use tools like [typedoc][typedoc] to generate docs from your types to
    share with consumers of your API.
 3. You can use the types of the module to coerce your client to adopt the
-   modules type.
-
-```bash
-# Create pretty docs for your module.
-npx typedoc my-module.ts
-```
-
-Now we can use the `my-module.ts` file for the client API.
+   module's type.
 
 ```ts
-import type * as MyModule from './my-module'
+import type * as math from './example/math.ts'
 
-import sendScriptApi from 'sendscript/api.mjs'
+import module from 'sendscript/module.mjs'
 
-export default sendScriptApi([
-  fnOne,
-  fnTwo,
-], /* perform websocket request */) as typeof MyModule
+export default module([
+  add,
+  squer,
+]) as typeof math
 ```
 
 > [!NOTE]
 > Although type coercion on the client side can improve the development
 > experience, it does not represent the actual type.
-> Values are likely subject to serialization and deserialization,
-> particularly when interfacing with JSON formats.
+> Values are subject to serialization and deserialization.
 
 ## Tests
 
@@ -230,19 +192,19 @@ npm t -- report text-summary
 ```
 ```
 
-> sendscript@0.1.4 test
+> sendscript@1.0.1 test
 > tap -R silent
 
 
-> sendscript@0.1.4 test
+> sendscript@1.0.1 test
 > tap report text-summary
 
 
 =============================== Coverage summary ===============================
-Statements   : 100% ( 110/110 )
-Branches     : 100% ( 32/32 )
-Functions    : 100% ( 10/10 )
-Lines        : 100% ( 110/110 )
+Statements   : 100% ( 239/239 )
+Branches     : 100% ( 71/71 )
+Functions    : 100% ( 18/18 )
+Lines        : 100% ( 239/239 )
 ================================================================================
 ```
 
@@ -278,6 +240,10 @@ No outdated packages found
 
 See the [LICENSE.txt][license] file for details.
 
+## Roadmap
+
+- [ ] Support for simple lambdas to compose functions more easily.
+
 [license]:./LICENSE.txt
 [socket.io]:https://socket.io/
 [changelog]:./CHANGELOG.md

package/README.mz

@@ -42,16 +42,17 @@ Here a socket.io server that runs SendScript programs.
 // ./example/server.socket.io.mjs
 
 import { Server } from 'socket.io'
-import exec from '../exec.mjs'
+import Parse from '../parse.mjs'
 import * as math from './math.mjs'
 
+const parse = Parse(math)
 const server = new Server()
 const port = process.env.PORT || 3000
 
 server.on('connection', (socket) => {
   socket.on('message', async (program, callback) => {
     try {
-      const result = await exec(math, program)
+      const result = parse(program)
       callback(null, result) // Pass null as the first argument to indicate success
     } catch (error) {
       callback(error) // Pass the error to the callback
@@ -71,14 +72,17 @@ Now for a client that sends a program to the server.
 // ./example/client.socket.io.mjs
 
 import socketClient from 'socket.io-client'
-import api from '../api.mjs'
+import stringify from '../stringify.mjs'
+import module from '../module.mjs'
+import * as math from './math.mjs'
+import assert from 'node:assert'
 
 const port = process.env.PORT || 3000
 const client = socketClient(`http://localhost:${port}`)
 
-const exec = program => {
+const send = program => {
   return new Promise((resolve, reject) => {
-    client.emit('message', program, (error, result) => {
+    client.emit('message', stringify(program), (error, result) => {
       error
         ? reject(error)
         : resolve(result)
@@ -86,11 +90,16 @@ const exec = program => {
   })
 }
 
-const { add, square } = api(['add', 'square'], exec)
+const { add, square } = module(math)
+
+// The program to be sent over the wire
+const program = square(add(1, add(add(2, 3), 4)))
+
+const result = await send(program)
+
+console.log('Result: ', result)
 
-console.log(
-  await square(add(1, add(add(2, 3), 4)))
-)
+assert.equal(result, 100)
 
 process.exit(0)
 ```
@@ -98,6 +107,8 @@ process.exit(0)
 Now we run this server and a client script.
 
 ```bash bash
+set -e
+
 # Run the server
 node ./example/server.socket.io.mjs&
 
@@ -107,99 +118,51 @@ node ./example/client.socket.io.mjs
 pkill sendscript
 ```
 
-## Reference
-
-SendScript is essentially a way to serialize a program to then send over the
-wire and execute it somewhere else.
-
-We only have two modules. One that helps you write programs that can be sent
-over the wire and another for running that program.
-
-### `sendscript/api.mjs`
-
-The api module exports a function that takes two arguments.
-
-1. The schema, which represents the values that are available.
-2. The function that will be called with the serializable version of the
-   program.
-
-It returns an object that contains functions which are defined in the schema.
-These functions are a JavaScript API for writing programs that can be sent to
-a server.
-
-```js
-import api from './api.mjs'
-
-const  { add, subtract } = api(
-  ['add', 'subtract'],
-  serializableProgram => sendSomewhereToBeExecuted(serializableProgram)
-)
-
-await add(1, 2) // => 3
-await subtract(1, 2) // => -1
-await add(1, subtract(2, 3)) // => 0
-```
-
-The add and subtract functions are thennable. The execute function is called as
-soon as await or `.then` is used.
+## Async/Await
 
-> Notice that you do not have to await the subtract call. You only need to
-> await when you want to execute the program.
+SendScript supports async/await seamlessly within a single request. This avoids the performance pitfalls of waterfall-style messaging, which can be especially slow on high-latency networks.
 
-This API is composable and wrappable.
-
-### `sendscript/exec.mjs`
-
-The exec function takes an environment object and any valid SendScript program.
+While it's possible to chain promises manually or use utility functions, native async/await support makes your code more readable, modern, and easier to reason about — aligning SendScript with today’s JavaScript best practices.
 
 ```js
-import exec from './exec.mjs'
+const userId = 'user-123'
+const program = {
+  unread: await fetchUnreadMessages(userId),
+  emptyTrash: await emptyTrash(userId),
+  archived: await archiveMessages(selectMessages({ old: true }))
+}
 
-exec({
-  add: (a, b) => a + b,
-  subtract: (a, b) => a - b
-}, ['add', 1, [subtract, 1, 2]])
+const result = await send(program)
 ```
 
-The array you see here is the LISP that SendScript uses to represent programs.
-
-You could use SendScript without knowing the details of how the LISP works. It
-is an implementation detail and might change over time.
+This operation is done in a single round-trip. The result is an object with the defined properties and returned values.
 
 ## TypeScript
 
-There is a good use-case to write an environment module in TypeScript.
+There is a good use-case to write a module in TypeScript.
 
 1. Obviously the module would have the benefits that TypeScript offers when
    coding.
 2. You can use tools like [typedoc][typedoc] to generate docs from your types to
    share with consumers of your API.
 3. You can use the types of the module to coerce your client to adopt the
-   modules type.
-
-```bash
-# Create pretty docs for your module.
-npx typedoc my-module.ts
-```
-
-Now we can use the `my-module.ts` file for the client API.
+   module's type.
 
 ```ts
-import type * as MyModule from './my-module'
+import type * as math from './example/math.ts'
 
-import sendScriptApi from 'sendscript/api.mjs'
+import module from 'sendscript/module.mjs'
 
-export default sendScriptApi([
-  fnOne,
-  fnTwo,
-], /* perform websocket request */) as typeof MyModule
+export default module([
+  add,
+  squer,
+]) as typeof math
 ```
 
 > [!NOTE]
 > Although type coercion on the client side can improve the development
 > experience, it does not represent the actual type.
-> Values are likely subject to serialization and deserialization,
-> particularly when interfacing with JSON formats.
+> Values are subject to serialization and deserialization.
 
 ## Tests
 
@@ -239,6 +202,10 @@ npm outdated && echo 'No outdated packages found'
 
 See the [LICENSE.txt][license] file for details.
 
+## Roadmap
+
+- [ ] Support for simple lambdas to compose functions more easily.
+
 [license]:./LICENSE.txt
 [socket.io]:https://socket.io/
 [changelog]:./CHANGELOG.md

package/example/client.socket.io.mjs

@@ -1,14 +1,17 @@
 // ./example/client.socket.io.mjs
 
 import socketClient from 'socket.io-client'
-import api from '../api.mjs'
+import stringify from '../stringify.mjs'
+import module from '../module.mjs'
+import * as math from './math.mjs'
+import assert from 'node:assert'
 
 const port = process.env.PORT || 3000
 const client = socketClient(`http://localhost:${port}`)
 
-const exec = program => {
+const send = program => {
   return new Promise((resolve, reject) => {
-    client.emit('message', program, (error, result) => {
+    client.emit('message', stringify(program), (error, result) => {
       error
         ? reject(error)
         : resolve(result)
@@ -16,10 +19,15 @@ const exec = program => {
   })
 }
 
-const { add, square } = api(['add', 'square'], exec)
+const { add, square } = module(math)
 
-console.log(
-  await square(add(1, add(add(2, 3), 4)))
-)
+// The program to be sent over the wire
+const program = square(add(1, add(add(2, 3), 4)))
+
+const result = await send(program)
+
+console.log('Result: ', result)
+
+assert.equal(result, 100)
 
 process.exit(0)

package/example/server.socket.io.mjs

@@ -1,16 +1,17 @@
 // ./example/server.socket.io.mjs
 
 import { Server } from 'socket.io'
-import exec from '../exec.mjs'
+import Parse from '../parse.mjs'
 import * as math from './math.mjs'
 
+const parse = Parse(math)
 const server = new Server()
 const port = process.env.PORT || 3000
 
 server.on('connection', (socket) => {
   socket.on('message', async (program, callback) => {
     try {
-      const result = await exec(math, program)
+      const result = parse(program)
       callback(null, result) // Pass null as the first argument to indicate success
     } catch (error) {
       callback(error) // Pass the error to the callback

package/index.mjs

@@ -1,4 +1,11 @@
-import api from './api.mjs'
-import exec from './exec.mjs'
+import stringify from './stringify.mjs'
+import makeModule from './module.mjs'
+import parse from './parse.mjs'
 
-export default { api, exec }
+export default function sendscript (module) {
+  return {
+    stringify,
+    parse: parse(module),
+    module: makeModule(module)
+  }
+}

package/index.test.mjs

@@ -0,0 +1,197 @@
+import { test } from 'tap'
+import Sendscript from './index.mjs'
+
+const module = {
+  add: (a, b) => a + b,
+  identity: (x) => x,
+  concat: (a, b) => a.concat(b),
+  toArray: (...array) => array,
+  always: (x) => () => x,
+  multiply3: (a) => (b) => (c) => a * b * c,
+  map: (fn) => (array) => array.map(fn),
+  filter: (pred) => (array) => array.filter(pred),
+  hello: 'world',
+  noop: () => {},
+  resolve: (x) => Promise.resolve(x),
+  asyncFn: async () => 'my-async-function',
+  instanceOf: (x, t) => x instanceof t,
+  asyncAdd: async (a, b) => a + b,
+  aPromise: Promise.resolve(42),
+  delayedIdentity: async (x) => x,
+  Function,
+  Promise
+}
+
+const sendscript = Sendscript(module)
+const { parse, stringify } = sendscript
+const run = (program) => parse(stringify(program))
+
+const RealPromise = Promise
+
+test('should evaluate basic expressions correctly', async (t) => {
+  const {
+    aPromise,
+    asyncAdd,
+    resolve,
+    delayedIdentity,
+    noop,
+    Function,
+    Promise,
+    instanceOf,
+    asyncFn,
+    hello,
+    map,
+    toArray,
+    add,
+    concat,
+    identity,
+    always,
+    multiply3
+  } = sendscript.module
+
+  t.test('nested await works', async (t) => {
+    // Async identity passthrough
+    const resolvedId = await delayedIdentity
+
+    t.equal(await run(resolvedId('X')), 'X')
+
+    t.end()
+  })
+
+  t.test('deep nested awaits', async (t) => {
+    const nested = async () => await RealPromise.resolve(await delayedIdentity('deep'))
+    t.equal(await run(await nested()), 'deep')
+    t.end()
+  })
+
+  t.test('awaits in nested array structure', async (t) => {
+    const arr = [
+      await resolve(1),
+      [await resolve(2), [await resolve(3)]],
+      await delayedIdentity(4)
+    ]
+    t.same(await run(arr), [1, [2, [3]], 4])
+    t.end()
+  })
+
+  t.test('awaits in deeply nested object structure', async (t) => {
+    const obj = {
+      a: await resolve('a'),
+      b: {
+        c: await delayedIdentity('c'),
+        d: {
+          e: await resolve('e')
+        }
+      }
+    }
+    t.same(await run(obj), {
+      a: 'a',
+      b: {
+        c: 'c',
+        d: { e: 'e' }
+      }
+    })
+    t.end()
+  })
+
+  t.test('await as computed value inside nested async function', async (t) => {
+    const asyncOuter = async () => {
+      const val = await delayedIdentity('nested')
+      return val
+    }
+    t.equal(await run(await asyncOuter()), 'nested')
+    t.end()
+  })
+
+  // return t.end()
+
+  t.test('promise resolution', async (t) => {
+    t.equal(await run(identity(await aPromise)), 42)
+    t.strictSame(await run(asyncFn()), 'my-async-function')
+    t.strictSame(await run(await resolve('my-promise')), 'my-promise')
+    t.strictSame(run(instanceOf(resolve(asyncFn), Promise)), true)
+    t.strictSame(
+      await run(instanceOf(await resolve(asyncFn), Function)), true
+    )
+    t.strictSame(
+      await run({ a: await resolve('b') }),
+      { a: 'b' }
+    )
+  })
+
+  await t.test('async and promise handling', async (t) => {
+    // Await inside run input
+    const resolvedAdd = await RealPromise.resolve(asyncAdd)
+    t.equal(await run(resolvedAdd(2, 3)), 5)
+
+    // Using asyncFn in a nested structure
+    const nestedAsync = async () => await asyncFn()
+    t.equal(await run(await nestedAsync()), 'my-async-function')
+
+    // Awaiting inside object structure
+    t.same(await run({
+      type: 'response',
+      data: await resolve('some-data')
+    }), {
+      type: 'response',
+      data: 'some-data'
+    })
+
+    t.end()
+  })
+
+  t.test('basic types and identity', (t) => {
+    t.equal(run(identity(null)), null)
+    t.equal(run(identity(undefined)), null)
+    t.equal(run(noop()), undefined)
+    t.equal(run(identity(1)), 1)
+    t.strictSame(run(identity([])), [])
+    t.strictSame(run(identity([identity(1), 2, 3])), [1, 2, 3])
+    t.strictSame(run(always('hello')()), 'hello')
+    t.end()
+  })
+
+  t.test('objects and arrays', (t) => {
+    t.strictSame(
+      run(identity({ a: identity(1), b: always(2)(), c: add(1, 2) })),
+      { a: 1, b: 2, c: 3 }
+    )
+    t.strictSame(run(concat([1, 2], [[add(1, 2)]])), [1, 2, [3]])
+    t.strictSame(run(concat([1, 2], [add(1, 2), add(2, 2)])), [1, 2, 3, 4])
+    t.strictSame(run(map(identity)([1, 2, 3, 4])), [1, 2, 3, 4])
+    t.end()
+  })
+
+  t.test('function composition and currying', (t) => {
+    t.strictSame(run(multiply3(1)(2)(3)), 6)
+    t.end()
+  })
+
+  t.test('special cases and errors', (t) => {
+    t.throws(() => parse('["ref", "notDefined"]'))
+    t.strictSame(
+      run(identity(['ref', 'doesNotExist'])),
+      ['ref', 'doesNotExist']
+    )
+    t.strictSame(
+      run(identity(['ref', 'hello'])),
+      run(identity(toArray('ref', 'hello')))
+    )
+    t.end()
+  })
+
+  t.test('primitives and built-ins', (t) => {
+    t.equal(JSON.stringify([undefined]), '[null]')
+    t.equal(run(hello), 'world')
+    t.equal(run(add(1, 2)), 3)
+    t.end()
+  })
+
+  t.test('identity with arrays', (t) => {
+    t.strictSame(
+      run(identity([identity(1), identity(2), identity(3), identity(4)])),
+      [1, 2, 3, 4]
+    )
+    t.end()
+  })
+})

package/is-nil.mjs

@@ -0,0 +1,3 @@
+const isNil = x => x == null
+
+export default isNil

package/module.mjs

@@ -0,0 +1,52 @@
+import {
+  awaitSymbol,
+  call,
+  ref
+} from './symbol.mjs'
+
+function instrument (name) {
+  function reference (...args) {
+    const called = instrument(name)
+
+    called.toJSON = () => ({
+      [call]: call,
+      call: true,
+      ref: reference,
+      args
+    })
+
+    return called
+  }
+
+  reference.then = (resolve) => {
+    const awaited = instrument(name)
+
+    delete awaited.then
+
+    awaited.toJSON = () => ({
+      [awaitSymbol]: awaitSymbol,
+      await: true,
+      ref: reference
+    })
+
+    return resolve(awaited)
+  }
+
+  reference.toJSON = () => ({
+    [ref]: ref,
+    reference: true,
+    name
+  })
+
+  return reference
+}
+
+export default function module (schema) {
+  if (!Array.isArray(schema)) return module(Object.keys(schema))
+
+  return schema.reduce((api, name) => {
+    api[name] = instrument(name)
+
+    return api
+  }, {})
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sendscript",
-  "version": "0.1.4",
+  "version": "1.0.1",
   "description": "Blur the line between server and client code.",
   "module": true,
   "main": "index.mjs",
@@ -17,15 +17,15 @@
   },
   "scripts": {
     "test": "tap",
-    "version": "npm run docs && git add *.md",
+    "version": "npm run docs && git add *.md example",
     "docs": "markatzea README.mz | tee README.md && npx markdown-toc -i README.md"
   },
   "author": "Bas Huis",
   "license": "MIT",
   "devDependencies": {
-    "tap": "^18.5.2"
+    "tap": "^21.0.1"
   },
   "dependencies": {
-    "debug": "^4.3.4"
+    "debug": "^4.3.7"
   }
 }

package/parse.mjs

@@ -0,0 +1,88 @@
+import Debug from './debug.mjs'
+import isNil from './is-nil.mjs'
+
+class SendScriptError extends Error {}
+class SendScriptReferenceError extends SendScriptError {}
+
+const debug = Debug.extend('parse')
+
+export default (env) =>
+  function parse (program) {
+    debug('program', program)
+
+    const awaits = []
+    const resolved = {}
+
+    JSON.parse(program, (key, value) => {
+      if (Array.isArray(value) && value[0] === 'await') {
+        awaits.push(((program, awaitId) => async () => {
+          const value = await JSON.parse(JSON.stringify(program), reviver)
+          resolved[awaitId] = value
+
+          debug('awaits', awaits)
+        })(value[1], value[2]))
+      }
+
+      return value
+    })
+
+    const spy = fn => (...args) => {
+      const value = fn(...args)
+      debug(args, ' => ', value)
+      return value
+    }
+
+    const reviver = spy((key, value) => {
+      if (isNil(value)) return value
+
+      if (!Array.isArray(value)) {
+        return value
+      }
+
+      const [operator, ...rest] = value
+
+      if (operator === 'await') {
+        const [, awaitId] = rest
+        debug('read awaits', resolved[awaitId], awaitId)
+
+        return resolved[awaitId]
+      }
+
+      if (Array.isArray(operator) && operator[0] === 'quote') {
+        const [, quoted] = operator
+
+        return [quoted, ...rest]
+      }
+
+      if (operator === 'call') {
+        const [fn, args] = rest
+
+        return fn(...args)
+      }
+
+      if (operator === 'ref') {
+        const [name] = rest
+
+        if (Object.hasOwn(env, name)) return env[name]
+
+        throw new SendScriptReferenceError({ key, value })
+      }
+
+      return value
+    })
+
+    if (awaits.length) {
+      return sequential(awaits).then(() => {
+        return JSON.parse(program, reviver)
+      })
+    }
+
+    return JSON.parse(program, reviver)
+  }
+
+function sequential (promises) {
+  return promises.reduce(
+    (acc, curr) => acc.then(results => curr().then(res => [...results, res])),
+    Promise.resolve([])
+  )
+}

package/stringify.mjs

@@ -0,0 +1,66 @@
+import Debug from './debug.mjs'
+import isNil from './is-nil.mjs'
+import {
+  awaitSymbol,
+  call,
+  ref
+} from './symbol.mjs'
+
+const debug = Debug.extend('stringify')
+
+const replaced = Symbol('replaced')
+const keywords = ['ref', 'call', 'quote', 'await']
+const isKeyword = (v) => keywords.includes(v)
+let awaitId = -1
+
+function replacer (key, value) {
+  debug(this, key, value)
+
+  if (isNil(value)) {
+    return value
+  }
+
+  if (value[ref]) {
+    const result = ['ref', value.name]
+
+    result[replaced] = replaced
+
+    return result
+  }
+
+  if (value[call]) {
+    const result = ['call', value.ref, value.args]
+
+    result[replaced] = replaced
+
+    return result
+  }
+
+  if (value[awaitSymbol]) {
+    awaitId += 1
+    const result = ['await', value.ref, awaitId]
+
+    result[replaced] = replaced
+
+    return result
+  }
+
+  // Quote only the reserved string and not the complete array. Quoted values
+  // will be unquoted on parse. A quoted quote also.
+  if (!value[replaced] && Array.isArray(value)) {
+    const [operator, ...rest] = value
+
+    if (isKeyword(operator)) {
+      const quoted = ['quote', operator]
+      quoted[replaced] = replaced
+
+      return [quoted, ...rest]
+    }
+  }
+
+  return value
+}
+
+export default function stringify (program) {
+  return JSON.stringify(program, replacer)
+}

package/symbol.mjs

@@ -0,0 +1,3 @@
+export const ref = Symbol('ref')
+export const call = Symbol('call')
+export const awaitSymbol = Symbol('await')

package/api.mjs

@@ -1,40 +0,0 @@
-import awaitWhen from './await-when.mjs'
-
-const symbol = Symbol('api')
-const isNotStub = v => v?.[symbol] !== symbol
-const awaitWhenNotStub = awaitWhen(isNotStub)
-
-/**
- * Create stubs to be used to build the program.
- *
- * @param {string[]} schema - Names of stubs.
- * @param {Function} call - Function to call when awaited.
- *
- * @return {Object} An object containing the named stubs.
- */
-export default function api (schema, call) {
-  return schema.reduce((api, name) => {
-    const then = (program) => (resolve, reject) =>
-      Promise.resolve(call(program)).then(resolve, reject)
-
-    const fn = (...args) => {
-      const toJSON = () => ['call', fn, args]
-
-      return {
-        [symbol]: symbol,
-        toJSON,
-        async then (resolve, reject) {
-          return then(await awaitWhenNotStub(toJSON()))(resolve, reject)
-        }
-      }
-    }
-
-    fn.toJSON = () => ['ref', name]
-    fn.then = then(fn)
-    fn[symbol] = symbol
-
-    api[name] = fn
-
-    return api
-  }, {})
-}

package/await-when.mjs

@@ -1,11 +0,0 @@
-import curry from './curry.mjs'
-
-export default curry(function awaitWhen (when, array) {
-  return array.reduce(async (asyncAcc, item) => {
-    const acc = await asyncAcc
-
-    acc.push(when(item) ? await item : item)
-
-    return acc
-  }, [])
-})

package/exec.mjs

@@ -1,43 +0,0 @@
-import _debug from './debug.mjs'
-import curry from './curry.mjs'
-
-const debug = _debug.extend('lisp')
-
-class SendScriptError extends Error {};
-class RefError extends SendScriptError {};
-
-const exec = curry(async (env, expression) => {
-  debug('exec', expression)
-
-  if (!Array.isArray(expression)) {
-    return expression
-  }
-
-  const [operator, ...args] = expression
-
-  if (operator === 'call') {
-    const [fnRef, fnArgs] = args
-
-    const fn = await exec(env, fnRef)
-    return fn.apply(env, await exec(env, fnArgs))
-  }
-
-  if (operator === 'ref') {
-    const [name] = args
-
-    if (!Object.hasOwn(env, name)) {
-      throw new RefError(expression)
-    }
-
-    return env[name]
-  }
-
-  return await Promise.all(expression.map(exec(env)))
-})
-
-export {
-  SendScriptError,
-  RefError
-}
-
-export default exec

package/exec.test.mjs

@@ -1,46 +0,0 @@
-import { test } from 'tap'
-import api from './api.mjs'
-import exec from './exec.mjs'
-
-test('should evaluate basic expressions correctly', async (t) => {
-  const module = {
-    add: (a, b) => a + b,
-    identity: x => x,
-    concat: (a, b) => a.concat(b)
-  }
-
-  const evaluate = exec(module)
-  const { add, concat, identity } = api(Object.keys(module), program =>
-    evaluate(JSON.parse(JSON.stringify(program))))
-
-  t.equal(
-    await evaluate(add(1, 2)),
-    3
-  )
-
-  t.strictSame(
-    await evaluate([]),
-    []
-  )
-
-  t.strictSame(
-    await evaluate(concat([1, 2], [[add(1, 2)]])),
-    [1, 2, [3]]
-  )
-
-  t.strictSame(
-    await evaluate(concat([1, 2], [add(1, 2), add(2, 2)])),
-    [1, 2, 3, 4]
-  )
-
-  t.strictSame(
-    await evaluate([identity(1), 2, 3]),
-    [1, 2, 3]
-  )
-
-  t.rejects(async () => {
-    await evaluate(['ref', 'doesNotExist'])
-  })
-
-  t.end()
-})