@weborigami/origami 0.6.9 → 0.6.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.6.9",
+  "version": "0.6.11",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.6.9",
+    "@weborigami/async-tree": "0.6.11",
     "@weborigami/json-feed-to-rss": "1.0.1",
-    "@weborigami/language": "0.6.9",
+    "@weborigami/language": "0.6.11",
     "css-tree": "3.1.0",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.11.1",

package/src/cli/cli.js

@@ -61,6 +61,6 @@ while (args[0] === "") {
 try {
   await main(...args);
 } catch (/** @type {any} */ error) {
-  console.error(formatError(error));
+  console.error(await formatError(error));
   process.exitCode = 1;
 }

package/src/dev/changes.js

@@ -1,4 +1,10 @@
-import { getTreeArgument, trailingSlash, Tree } from "@weborigami/async-tree";
+import {
+  args,
+  isStringlike,
+  toString,
+  trailingSlash,
+  Tree,
+} from "@weborigami/async-tree";
 
 /**
  * Given an old tree and a new tree, return a tree of changes indicated
@@ -10,13 +16,13 @@ import { getTreeArgument, trailingSlash, Tree } from "@weborigami/async-tree";
  * @param {Maplike} newMaplike
  */
 export default async function changes(oldMaplike, newMaplike) {
-  const oldTree = await getTreeArgument(oldMaplike, "changes", {
+  const oldTree = await args.map(oldMaplike, "Dev.changes", {
     deep: true,
-    position: 0,
+    position: 1,
   });
-  const newTree = await getTreeArgument(newMaplike, "changes", {
+  const newTree = await args.map(newMaplike, "Dev.changes", {
     deep: true,
-    position: 1,
+    position: 2,
   });
 
   const oldKeys = await Tree.keys(oldTree);
@@ -44,9 +50,9 @@ export default async function changes(oldMaplike, newMaplike) {
         result ??= {};
         result[oldKey] = treeChanges;
       }
-    } else if (oldValue?.toString && newValue?.toString) {
-      const oldText = oldValue.toString();
-      const newText = newValue.toString();
+    } else if (isStringlike(oldValue) && isStringlike(newValue)) {
+      const oldText = toString(oldValue);
+      const newText = toString(newValue);
       if (oldText !== newText) {
         result ??= {};
         result[oldKey] = "changed";

package/src/dev/copy.js

@@ -1,10 +1,4 @@
-import {
-  AsyncMap,
-  getTreeArgument,
-  SyncMap,
-  Tree,
-} from "@weborigami/async-tree";
-import { formatError } from "@weborigami/language";
+import { args, AsyncMap, SyncMap, Tree } from "@weborigami/async-tree";
 import process, { stdout } from "node:process";
 
 /**
@@ -14,8 +8,8 @@ import process, { stdout } from "node:process";
  * @param {Maplike} target
  */
 export default async function copy(source, target) {
-  const sourceTree = await getTreeArgument(source, "copy", { position: 0 });
-  let targetTree = await getTreeArgument(target, "copy", { position: 1 });
+  const sourceTree = await args.map(source, "Dev.copy", { position: 1 });
+  let targetTree = await args.map(target, "Dev.copy", { position: 2 });
 
   let progressTree;
   if (stdout.isTTY) {
@@ -64,17 +58,12 @@ function showSetProgress(source, counts) {
     set(key, value) {
       counts.total++;
       showProgress();
-      try {
-        const setResult = source.set(key, value);
-        return awaitIfPromise(setResult, () => {
-          counts.copied++;
-          showProgress();
-          return progressTree;
-        });
-      } catch (/** @type {any} */ error) {
-        console.error(formatError(error));
+      const setResult = source.set(key, value);
+      return awaitIfPromise(setResult, () => {
+        counts.copied++;
+        showProgress();
         return progressTree;
-      }
+      });
     },
   });
 

package/src/dev/crawler/crawlResources.js

@@ -37,7 +37,7 @@ export default async function* crawlResources(tree, baseUrl) {
   while (true) {
     // Get the latest array of promises that haven't been resolved yet.
     const promises = Object.values(promisesForPaths).filter(
-      (promise) => promise !== null
+      (promise) => promise !== null,
     );
 
     if (promises.length === 0) {
@@ -136,7 +136,7 @@ async function processPath(tree, path, baseUrl) {
     value = await Tree.traverse(tree, ...keys);
     normalizedKeys = keys.slice();
     normalizedPath = path;
-    if (Tree.isMaplike(value)) {
+    if (value && Tree.isMaplike(value)) {
       // Path is actually a directory. See if we can get the empty string or
       // "index.html".
       value =
@@ -196,7 +196,7 @@ async function processPath(tree, path, baseUrl) {
     value,
     key,
     baseUrl,
-    normalizedPath
+    normalizedPath,
   );
 
   return {

package/src/dev/crawler/getSiteArgument.js

@@ -1,4 +1,4 @@
-import { getTreeArgument, SiteMap } from "@weborigami/async-tree";
+import { args, SiteMap } from "@weborigami/async-tree";
 
 /**
  * Return a site: if it's a tree, return the tree; if it's a string, create a
@@ -8,5 +8,5 @@ export default async function getSiteArgument(site, command) {
   if (typeof site === "string") {
     return new SiteMap(site);
   }
-  return getTreeArgument(site, command);
+  return args.map(site, command);
 }

package/src/dev/debug.js

@@ -1,4 +1,4 @@
-import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { args, Tree } from "@weborigami/async-tree";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
 import ExplorableSiteTransform from "./ExplorableSiteTransform.js";
 import OriCommandTransform from "./OriCommandTransform.js";
@@ -13,7 +13,7 @@ import OriCommandTransform from "./OriCommandTransform.js";
  * @returns {Promise<Map|AsyncMap>}
  */
 export default async function debug(maplike) {
-  let tree = await getTreeArgument(maplike, "debug");
+  let tree = await args.map(maplike, "Dev.debug");
 
   if (!isTransformApplied(DebugTransform, tree)) {
     tree = transformObject(DebugTransform, tree);

package/src/dev/explore.js

@@ -1,4 +1,4 @@
-import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { args, Tree } from "@weborigami/async-tree";
 import { Handlers, OrigamiFileMap } from "@weborigami/language";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -11,7 +11,7 @@ let templatePromise;
  * Display a debug/explore page for the current tree.
  */
 export default async function explore(maplike) {
-  const tree = await getTreeArgument(maplike, "explore");
+  const tree = await args.map(maplike, "Dev.explore");
 
   // Construct the template page
   const scope = await Tree.scope(tree);

package/src/dev/serve.js

@@ -1,4 +1,4 @@
-import { getTreeArgument } from "@weborigami/async-tree";
+import { args } from "@weborigami/async-tree";
 import http from "node:http";
 import { createServer } from "node:net";
 import process from "node:process";
@@ -17,7 +17,11 @@ const defaultPort = 5000;
  * @param {number} [port]
  */
 export default async function serve(maplike, port) {
-  let tree = await getTreeArgument(maplike, "serve");
+  let tree = await args.map(maplike, "Dev.serve");
+  port =
+    port !== undefined
+      ? args.number(port, "Dev.serve", { position: 2 })
+      : undefined;
 
   if (!isTransformApplied(ExplorableSiteTransform, tree)) {
     tree = transformObject(ExplorableSiteTransform, tree);
@@ -36,7 +40,7 @@ export default async function serve(maplike, port) {
   // @ts-ignore
   http.createServer(requestListener(tree)).listen(port, undefined, () => {
     console.log(
-      `Server running at http://localhost:${port}. Press Ctrl+C to stop.`
+      `Server running at http://localhost:${port}. Press Ctrl+C to stop.`,
     );
   });
 }
@@ -48,9 +52,9 @@ function findOpenPort(port) {
   return new Promise((resolve, reject) =>
     server
       .on("error", (/** @type {any} */ error) =>
-        error.code === "EADDRINUSE" ? server.listen(++port) : reject(error)
+        error.code === "EADDRINUSE" ? server.listen(++port) : reject(error),
       )
       .on("listening", () => server.close(() => resolve(port)))
-      .listen(port)
+      .listen(port),
   );
 }

package/src/dev/svg.js

@@ -1,4 +1,4 @@
-import { getTreeArgument } from "@weborigami/async-tree";
+import { args } from "@weborigami/async-tree";
 import graphviz from "graphviz-wasm";
 
 import dot from "./treeDot.js";
@@ -19,7 +19,7 @@ export default async function svg(maplike, options = {}) {
     await graphviz.loadWASM();
     graphvizLoaded = true;
   }
-  const tree = await getTreeArgument(maplike, "svg", { deep: true });
+  const tree = await args.map(maplike, "Dev.svg", { deep: true });
   const dotText = await dot(tree, options);
   if (dotText === undefined) {
     return undefined;

package/src/dev/treeDot.js

@@ -1,6 +1,6 @@
 import {
   Tree,
-  getTreeArgument,
+  args,
   isPlainObject,
   isStringlike,
   toString,
@@ -19,7 +19,7 @@ import { getDescriptor } from "../common/utilities.js";
  * @param {PlainObject} [options]
  */
 export default async function dot(maplike, options = {}) {
-  const tree = await getTreeArgument(maplike, "treeDot", { deep: true });
+  const tree = await args.map(maplike, "Dev.treeDot", { deep: true });
   const rootLabel = getDescriptor(tree) ?? "";
   const treeArcs = await statements(tree, "", rootLabel, options);
   return `digraph g {
@@ -43,7 +43,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
   const url = createLinks ? `; URL="${rootUrl}"` : "";
   const rootLabel = nodeLabel ? `; xlabel="${nodeLabel}"` : "";
   result.push(
-    `  "${nodePath}" [shape=circle${rootLabel}; label=""; color=gray40; width=0.15${url}];`
+    `  "${nodePath}" [shape=circle${rootLabel}; label=""; color=gray40; width=0.15${url}];`,
   );
 
   // Draw edges and collect labels for the nodes they lead to.
@@ -63,7 +63,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
       value =
         error.name && error.message
           ? `${error.name}: ${error.message}`
-          : error.name ?? error.message ?? error;
+          : (error.name ?? error.message ?? error);
     }
 
     const expandable =
@@ -76,8 +76,8 @@ async function statements(tree, nodePath, nodeLabel, options) {
       const label = isStringlike(value)
         ? toString(value)
         : value !== undefined
-        ? await serialize.toYaml(value)
-        : "";
+          ? await serialize.toYaml(value)
+          : "";
       if (value === undefined) {
         isError = true;
       }

package/src/dev/watch.js

@@ -1,4 +1,4 @@
-import { ConstantMap, getTreeArgument, Tree } from "@weborigami/async-tree";
+import { args, ConstantMap, Tree } from "@weborigami/async-tree";
 import { formatError, moduleCache } from "@weborigami/language";
 
 /**
@@ -13,7 +13,10 @@ import { formatError, moduleCache } from "@weborigami/language";
  * @returns {Promise<Map|AsyncMap>}
  */
 export default async function watch(maplike, fn) {
-  const container = await getTreeArgument(maplike, "watch");
+  const container = await args.map(maplike, "Dev.watch");
+  const treeFn = fn
+    ? args.invocable(fn, "Dev.watch", { position: 2 })
+    : undefined;
 
   // Watch the indicated tree.
   /** @type {any} */ (container).watch?.();
@@ -23,7 +26,7 @@ export default async function watch(maplike, fn) {
   }
 
   // The caller supplied a function to reevaluate whenever the tree changes.
-  let tree = await evaluateTree(container, fn);
+  let tree = await evaluateTree(container, treeFn);
 
   // We want to return a stable reference to the tree, so we'll use a prototype
   // chain that will always point to the latest tree. We'll extend the tree's
@@ -33,7 +36,7 @@ export default async function watch(maplike, fn) {
 
   // Reevaluate the function whenever the tree changes.
   /** @type {any} */ (container).addEventListener?.("change", async () => {
-    const tree = await evaluateTree(container, fn);
+    const tree = await evaluateTree(container, treeFn);
     moduleCache.resetTimestamp();
     updateIndirectPointer(handle, tree);
   });
@@ -48,7 +51,7 @@ async function evaluateTree(parent, fn) {
   try {
     result = await fn();
   } catch (/** @type {any} */ error) {
-    message = formatError(error);
+    message = await formatError(error);
   }
   tree = result ? Tree.from(result, { parent }) : undefined;
   if (tree) {

package/src/origami/basename.js

@@ -1,6 +1,7 @@
-import { extension } from "@weborigami/async-tree";
+import { args, extension } from "@weborigami/async-tree";
 
 export default function basename(key) {
+  key = args.string(key, "Origami.basename");
   const ext = extension.extname(key);
   return ext ? key.slice(0, -ext.length) : key;
 }

package/src/origami/csv.js

@@ -3,8 +3,9 @@ import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 /**
  * Render the object as text in CSV format.
  *
- * The object should a maplike object such as an array. The output will include
- * a header row with field names taken from the first item in the tree/array.
+ * The object should be a maplike object such as an array. The output will
+ * include a header row with field names taken from the first item in the
+ * tree/array.
  *
  * @param {any} object
  */

package/src/origami/document.js

@@ -1,11 +1,20 @@
+import { args, isPlainObject, isUnpackable } from "@weborigami/async-tree";
 import documentObject from "../common/documentObject.js";
 
 /**
  * @typedef {import("@weborigami/async-tree").Stringlike} Stringlike
+ * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  *
- * @param {Stringlike} text
+ * @param {Stringlike|PlainObject} input
  * @param {any} [data]
  */
-export default async function documentBuiltin(text, data) {
-  return documentObject(text, data);
+export default async function documentBuiltin(input, data) {
+  if (isUnpackable(input)) {
+    // Unpack the input first, might already be a document object.
+    input = await input.unpack();
+  }
+  input = isPlainObject(input)
+    ? input
+    : args.stringlike(input, "Origami.document");
+  return documentObject(input, data);
 }

package/src/origami/fetch.js

@@ -1,3 +1,4 @@
+import { args } from "@weborigami/async-tree";
 import { handleExtension } from "@weborigami/language";
 
 /**
@@ -5,6 +6,7 @@ import { handleExtension } from "@weborigami/language";
  * with an unpack() method if the resource has a known file extension.
  */
 export default async function fetchBuiltin(resource, options, state) {
+  resource = args.string(resource, "Origami.fetch");
   const response = await fetch(resource, options);
   if (!response.ok) {
     return undefined;
@@ -15,6 +17,6 @@ export default async function fetchBuiltin(resource, options, state) {
   const url = new URL(resource);
   const key = url.pathname;
 
-  return handleExtension(value, key, state.container);
+  return handleExtension(value, key, state?.parent);
 }
 fetchBuiltin.needsState = true;

package/src/origami/htmlDom.js

@@ -1,6 +1,13 @@
+import { args } from "@weborigami/async-tree";
 import loadJsDom from "../common/loadJsDom.js";
 
+/**
+ * Return the DOM for the given HTML string.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} html
+ */
 export default async function htmlDom(html) {
+  html = args.stringlike(html, "Origami.htmlDom");
   const { JSDOM } = await loadJsDom();
   const dom = JSDOM.fragment(html);
   return dom;

package/src/origami/htmlEscape.js

@@ -1,4 +1,4 @@
-import { toString } from "@weborigami/async-tree";
+import { args, toString } from "@weborigami/async-tree";
 import loadJsDom from "../common/loadJsDom.js";
 
 /**
@@ -7,8 +7,9 @@ import loadJsDom from "../common/loadJsDom.js";
  * @param {import("@weborigami/async-tree").Stringlike} html
  */
 export default async function htmlEscape(html) {
+  const text = args.stringlike(html, "Origami.htmlEscape");
   const { JSDOM } = await loadJsDom();
   const div = JSDOM.fragment("<div></div>").firstChild;
-  div.textContent = toString(html);
+  div.textContent = toString(text);
   return div.innerHTML;
 }

package/src/origami/image/format.js

@@ -1,4 +1,4 @@
-import sharp from "sharp";
+let sharp;
 
 /**
  * Return the image in a different format.
@@ -9,6 +9,11 @@ import sharp from "sharp";
  * @param {any} options
  */
 export default async function imageFormat(input, format, options) {
+  if (!sharp) {
+    // Dynamic import to avoid loading Sharp until needed
+    sharp = (await import("sharp")).default;
+  }
+
   if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
     return undefined;
   }

package/src/origami/image/resize.js

@@ -1,4 +1,4 @@
-import sharp from "sharp";
+let sharp;
 
 /**
  * Resize an image.
@@ -7,6 +7,11 @@ import sharp from "sharp";
  * @param {import("sharp").ResizeOptions} options
  */
 export default async function resize(input, options) {
+  if (!sharp) {
+    // Dynamic import to avoid loading Sharp until needed
+    sharp = (await import("sharp")).default;
+  }
+
   if (!(input instanceof Uint8Array || input instanceof ArrayBuffer)) {
     return undefined;
   }

package/src/origami/indexPage.js

@@ -1,4 +1,4 @@
-import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { args, Tree } from "@weborigami/async-tree";
 import { getDescriptor } from "../common/utilities.js";
 
 /**
@@ -10,12 +10,16 @@ import { getDescriptor } from "../common/utilities.js";
  * @param {string} [basePath]
  */
 export default async function indexPage(maplike, basePath) {
-  const tree = await getTreeArgument(maplike, "svg");
+  const tree = await args.map(maplike, "Origami.indexPage");
+  if (basePath !== undefined) {
+    basePath = args.string(basePath, "Origami.indexPage", { position: 2 });
+  }
+
   const treeKeys = await Tree.keys(tree);
 
   // Skip system-ish files that start with a period. Also skip `index.html`.
   const filtered = treeKeys.filter(
-    (key) => !(key.startsWith?.(".") || key === "index.html")
+    (key) => !(key.startsWith?.(".") || key === "index.html"),
   );
 
   const links = [];

package/src/origami/inline.js

@@ -6,7 +6,6 @@ import documentObject from "../common/documentObject.js";
  * Inline any Origami expressions found inside ${...} placeholders in the input
  * text.
  *
- *
  * @param {any} input
  */
 export default async function inline(input, options = {}) {
@@ -17,7 +16,9 @@ export default async function inline(input, options = {}) {
   const inputIsDocument = input._body !== undefined;
   const origami = inputIsDocument ? input._body : toString(input);
   if (origami === null) {
-    return undefined;
+    throw new Error(
+      "Origami.inline: The provided input couldn't be treated as text.",
+    );
   }
 
   const parent =
@@ -29,7 +30,7 @@ export default async function inline(input, options = {}) {
   if (inputIsDocument) {
     // Collect all document properties except the body
     front = Object.fromEntries(
-      Object.entries(input).filter(([key]) => key !== "_body")
+      Object.entries(input).filter(([key]) => key !== "_body"),
     );
   } else {
     front = null;

package/src/origami/json.js

@@ -3,15 +3,9 @@ import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 /**
  * Render the given object in JSON format.
  *
- *
- * @param {any} [obj]
+ * @param {any} obj
  */
 export default async function json(obj) {
-  if (arguments.length > 0 && obj === undefined) {
-    throw new Error(
-      "An Origami function was called with an initial argument, but its value is undefined."
-    );
-  }
   if (obj === undefined) {
     return undefined;
   }

package/src/origami/jsonKeys.js

@@ -1,9 +1,4 @@
-import {
-  AsyncMap,
-  Tree,
-  getTreeArgument,
-  jsonKeys,
-} from "@weborigami/async-tree";
+import { AsyncMap, Tree, args, jsonKeys } from "@weborigami/async-tree";
 
 /**
  * Expose .keys.json for a tree.
@@ -14,7 +9,7 @@ import {
  * @returns {Promise<AsyncMap>}
  */
 export default async function jsonKeysBuiltin(maplike) {
-  const source = await getTreeArgument(maplike, "jsonKeys");
+  const source = await args.map(maplike, "Origami.jsonKeys");
   return jsonKeysMap(source);
 }
 

package/src/origami/jsonParse.js

@@ -1,6 +1,11 @@
-import { toString } from "@weborigami/async-tree";
+import { args } from "@weborigami/async-tree";
 
+/**
+ * Parse the input as JSON.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} input
+ */
 export default async function jsonParse(input) {
-  const text = toString(input);
+  const text = args.stringlike(input, "Origami.jsonParse");
   return text ? JSON.parse(text) : undefined;
 }

package/src/origami/mdHtml.js

@@ -25,7 +25,7 @@ marked.use(
   markedSmartypants(),
   {
     gfm: true, // Use GitHub-flavored markdown.
-  }
+  },
 );
 
 /**
@@ -35,8 +35,8 @@ marked.use(
  */
 export default async function mdHtml(input) {
   if (input == null) {
-    const error = new TypeError("mdHtml: The input is not defined.");
-    /** @type {any} */ (error).position = 0;
+    const error = new TypeError("Origami.mdHtml: The input is not defined.");
+    /** @type {any} */ (error).position = 1;
     throw error;
   }
   if (isUnpackable(input)) {
@@ -45,7 +45,9 @@ export default async function mdHtml(input) {
   const inputIsDocument = typeof input === "object" && "_body" in input;
   const markdown = inputIsDocument ? input._body : toString(input);
   if (markdown === null) {
-    throw new Error("mdHtml: The provided input couldn't be treated as text.");
+    throw new Error(
+      "Origami.mdHtml: The provided input couldn't be treated as text.",
+    );
   }
   const html = marked.parse(markdown);
   return inputIsDocument ? documentObject(html, input) : html;

package/src/origami/mdOutline.js

@@ -8,7 +8,9 @@ export default async function mdOutline(input) {
   const inputIsDocument = typeof input === "object" && "_body" in input;
   const markdown = inputIsDocument ? input._body : toString(input);
   if (markdown === null) {
-    throw new Error("mdHtml: The provided input couldn't be treated as text.");
+    throw new Error(
+      "Origami.mdOutline: The provided input couldn't be treated as text.",
+    );
   }
 
   // Call the marked lexer to parse the markdown into tokens

package/src/origami/once.js

@@ -1,13 +1,15 @@
+import { args } from "@weborigami/async-tree";
+
 const fnPromiseMap = new Map();
 const codePromiseMap = new Map();
 
 /**
  * Evaluate the given function only once and cache the result.
  *
- *
  * @param {Function} fn
  */
 export default async function once(fn) {
+  fn = args.fn(fn, "Origami.once");
   const code = /** @type {any} */ (fn).code;
   if (code) {
     // Origami function, cache by code

package/src/origami/ori.js

@@ -1,9 +1,4 @@
-import {
-  Tree,
-  getRealmObjectPrototype,
-  isStringlike,
-  toString,
-} from "@weborigami/async-tree";
+import { Tree, args, getRealmObjectPrototype } from "@weborigami/async-tree";
 import { compile, projectGlobals } from "@weborigami/language";
 import { toYaml } from "../common/serialize.js";
 import * as dev from "../dev/dev.js";
@@ -14,19 +9,13 @@ const TypedArray = Object.getPrototypeOf(Uint8Array);
  * Parse an Origami expression, evaluate it in the context of a tree (provided
  * by `this`), and return the result as text.
  *
- *
- * @param {string} expression
+ * @param {import("@weborigami/async-tree").Stringlike} expression
  */
 export default async function ori(expression, options = {}) {
   const parent = options.parent ?? null;
   const formatResult = options.formatResult ?? true;
 
-  // In case expression has come from a file, cast it to a string.
-  if (!isStringlike(expression)) {
-    throw new TypeError("ori: The expression is not text.");
-  }
-  // @ts-ignore
-  expression = toString(expression);
+  expression = args.stringlike(expression, "Origami.ori");
 
   // Add Dev builtins as top-level globals
   const globals = {
@@ -65,6 +54,14 @@ async function format(result) {
     return result;
   }
 
+  if (result instanceof Response) {
+    if (!result.ok) {
+      console.warn(`Response not OK: ${result.status} ${result.statusText}`);
+      return undefined;
+    }
+    return await result.arrayBuffer();
+  }
+
   /** @type {string|String|undefined} */
   let text;
 

package/src/origami/origami.js

@@ -1,10 +1,10 @@
 export { extension } from "@weborigami/async-tree";
 export { default as help } from "../dev/help.js"; // Alias
-export { default as document } from "./document.js";
-// export { default as htmlDom } from "./htmlDom.js";
 export { default as basename } from "./basename.js";
 export { default as csv } from "./csv.js";
+export { default as document } from "./document.js";
 export { default as fetch } from "./fetch.js";
+export { default as htmlDom } from "./htmlDom.js";
 export { default as htmlEscape } from "./htmlEscape.js";
 export { default as format } from "./image/format.js";
 export * as image from "./image/image.js";

package/src/origami/pack.js

@@ -1,4 +1,5 @@
 /**
+ * Invoke the `pack` method of an object, if it exists.
  *
  * @param {any} obj
  */

package/src/origami/post.js

@@ -1,4 +1,5 @@
 import {
+  args,
   isStringlike,
   isUnpackable,
   toPlainValue,
@@ -13,6 +14,7 @@ import {
  * @param {any} data
  */
 export default async function post(url, data) {
+  url = args.string(url, "Origami.post");
   let body;
   let headers;
   if (isUnpackable(data)) {
@@ -39,7 +41,7 @@ export default async function post(url, data) {
   });
   if (!response.ok) {
     throw new Error(
-      `Failed to POST to ${url}. Error ${response.status}: ${response.statusText}`
+      `Failed to POST to ${url}. Error ${response.status}: ${response.statusText}`,
     );
   }
   return response.arrayBuffer();

package/src/origami/redirect.js

@@ -1,4 +1,13 @@
+import { args } from "@weborigami/async-tree";
+
+/**
+ * Generate a live or static redirect response.
+ *
+ * @param {string} url
+ * @param {{ permanent?: boolean }} [options]
+ */
 export default function redirect(url, options = { permanent: false }) {
+  url = args.string(url, "Origami.redirect");
   const response = new Response("ok", {
     headers: {
       Location: url,

package/src/origami/repeat.js

@@ -1,5 +1,14 @@
-export default async function repeat(count, content) {
+import { args } from "@weborigami/async-tree";
+
+/**
+ * Return an array of a given length, filled with the given value.
+ *
+ * @param {number} count
+ * @param {any} value
+ */
+export default async function repeat(count, value) {
+  count = args.number(count, "Origami.repeat");
   const array = new Array(count);
-  array.fill(content);
+  array.fill(value);
   return array;
 }

package/src/origami/rss.js

@@ -1,4 +1,4 @@
-import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { args, Tree } from "@weborigami/async-tree";
 import jsonFeedToRss from "@weborigami/json-feed-to-rss";
 
 /**
@@ -8,7 +8,7 @@ import jsonFeedToRss from "@weborigami/json-feed-to-rss";
  * @param {any} options
  */
 export default async function rss(jsonFeed, options = {}) {
-  const tree = await getTreeArgument(jsonFeed, "rss");
+  const tree = await args.map(jsonFeed, "Origami.rss");
   const jsonFeedPlain = await Tree.plain(tree);
   return jsonFeedToRss(jsonFeedPlain, options);
 }

package/src/origami/shell.js

@@ -1,13 +1,20 @@
+import { args } from "@weborigami/async-tree";
 import { exec as callbackExec } from "node:child_process";
 import util from "node:util";
 const exec = util.promisify(callbackExec);
 
+/**
+ * Return the standard output of invoking the given shell command.
+ *
+ * @param {string} command
+ */
 export default async function shell(command) {
+  command = args.string(command, "Origami.shell");
   try {
     const { stdout } = await exec(command);
     return stdout;
-  } catch (err) {
-    console.error(err);
+  } catch (/** @type {any} */ error) {
+    console.error(error.stderr);
     return undefined;
   }
 }

package/src/origami/sitemap.js

@@ -1,4 +1,4 @@
-import { getTreeArgument, Tree } from "@weborigami/async-tree";
+import { args, Tree } from "@weborigami/async-tree";
 import { ori_handler } from "@weborigami/language/src/handlers/handlers.js";
 
 const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
@@ -18,12 +18,12 @@ const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
  * @returns {Promise<string>}
  */
 export default async function sitemap(maplike, options = {}) {
-  const tree = await getTreeArgument(maplike, "sitemap");
+  const tree = await args.map(maplike, "Origami.sitemap");
 
   // We're only interested in keys that end in .html or with no extension.
   const filtered = await Tree.filter(
     tree,
-    (value, key) => key.endsWith?.(".html") || !key.includes?.(".")
+    (value, key) => key.endsWith?.(".html") || !key.includes?.("."),
   );
 
   const treePaths = await Tree.paths(filtered, options);

package/src/origami/slug.js

@@ -1,5 +1,15 @@
-export default function slug(filename) {
-  let slug = filename.toLowerCase();
+import { args } from "@weborigami/async-tree";
+
+/**
+ * Return a slug version of the given text: lowercase, spaces replaced by
+ * dashes, and special characters removed.
+ *
+ * @param {string} text
+ */
+export default function slug(text) {
+  text = args.string(text, "Origami.slug");
+
+  let slug = text.toLowerCase();
 
   // Convert spaces to dashes
   slug = slug.replace(/\s+/g, "-");

package/src/origami/static.js

@@ -1,9 +1,4 @@
-import {
-  AsyncMap,
-  Tree,
-  getTreeArgument,
-  jsonKeys,
-} from "@weborigami/async-tree";
+import { AsyncMap, Tree, args, jsonKeys } from "@weborigami/async-tree";
 import indexPage from "./indexPage.js";
 
 /**
@@ -15,7 +10,7 @@ import indexPage from "./indexPage.js";
  * @returns {Promise<AsyncMap>}
  */
 export default async function staticBuiltin(maplike) {
-  const source = await getTreeArgument(maplike, "static");
+  const source = await args.map(maplike, "Origami.static");
   return staticMap(source);
 }
 

package/src/origami/unpack.js

@@ -6,7 +6,9 @@
  */
 export default function unpack(obj) {
   if (obj == null) {
-    throw new ReferenceError("Cannot unpack null or undefined value");
+    throw new ReferenceError(
+      "Origami.unpack: Cannot unpack a null or undefined value",
+    );
   }
   return obj.unpack?.() ?? obj;
 }

package/src/origami/yaml.js

@@ -4,15 +4,9 @@ import YAML from "yaml";
 /**
  * Render the object as text in YAML format.
  *
- * @param {any} [obj]
+ * @param {any} obj
  */
 export default async function yamlBuiltin(obj) {
-  // A fragment of the logic from getTreeArgument.js
-  if (arguments.length > 0 && obj === undefined) {
-    throw new Error(
-      "An Origami function was called with an initial argument, but its value is undefined."
-    );
-  }
   if (obj === undefined) {
     return undefined;
   }

package/src/origami/yamlParse.js

@@ -1,7 +1,12 @@
-import { toString } from "@weborigami/async-tree";
+import { args } from "@weborigami/async-tree";
 import * as serialize from "../common/serialize.js";
 
+/**
+ * Parse the given YAML text and return the resulting value.
+ *
+ * @param {import("@weborigami/async-tree").Stringlike} input
+ */
 export default async function yamlParse(input) {
-  const text = toString(input);
+  const text = args.stringlike(input, "Origami.yamlParse");
   return text ? serialize.parseYaml(text) : undefined;
 }

package/src/server/server.js

@@ -119,8 +119,8 @@ export function requestListener(maplike) {
  * Construct a page in response in the given error, and also show the error in
  * the console.
  */
-export function respondWithError(response, error) {
-  let message = formatError(error);
+export async function respondWithError(response, error) {
+  let message = await formatError(error);
   // Remove ANSI escape codes from the message.
   message = message.replace(/\x1b\[[0-9;]*m/g, "");
   // Prevent HTML in the error message from being interpreted as HTML.