@weborigami/origami 0.0.48 → 0.0.49

package/exports/exports.js

@@ -1,4 +1,5 @@
 // This file is generated by running buildExports.js -- do not edit by hand.
+export { default as addNextPrevious } from "../src/builtins/@addNextPrevious.js";
 export { default as apply } from "../src/builtins/@apply.js";
 export { default as arrows } from "../src/builtins/@arrows.js";
 export { default as basename } from "../src/builtins/@basename.js";
@@ -38,6 +39,7 @@ export { default as js } from "../src/builtins/@js.js";
 export { default as json } from "../src/builtins/@json.js";
 export { default as keys } from "../src/builtins/@keys.js";
 export { default as keysJson } from "../src/builtins/@keysJson.js";
+export { default as makeParser } from "../src/builtins/@makeParser.js";
 export { default as map } from "../src/builtins/@map.js";
 export { default as mapDeep } from "../src/builtins/@mapDeep.js";
 export { default as match } from "../src/builtins/@match.js";
@@ -72,6 +74,7 @@ export { default as setDeep } from "../src/builtins/@setDeep.js";
 export { default as shell } from "../src/builtins/@shell.js";
 export { default as shuffle } from "../src/builtins/@shuffle.js";
 export { default as sitemap } from "../src/builtins/@sitemap.js";
+export { default as slug } from "../src/builtins/@slug.js";
 export { default as sort } from "../src/builtins/@sort.js";
 export { default as sortBy } from "../src/builtins/@sortBy.js";
 export { default as static } from "../src/builtins/@static.js";

package/index.ts

@@ -4,7 +4,6 @@
  */
 
 import { Treelike, Unpackable } from "@weborigami/async-tree";
-import { AsyncTree } from "@weborigami/types";
 
 /**
  * A class constructor is an object with a `new` method that returns an
@@ -21,5 +20,3 @@ export interface JsonObject {
 export type JsonValue = boolean | number | string | Date | JsonObject | JsonValue[] | null;
 
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-
-export type TreelikeTransform = (value: Treelike) => AsyncTree;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -13,22 +13,22 @@
   "main": "./exports/exports.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "20.11.27",
-    "typescript": "5.4.2"
+    "@types/node": "20.12.7",
+    "typescript": "5.4.5"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.48",
-    "@weborigami/language": "0.0.48",
-    "@weborigami/types": "0.0.48",
+    "@weborigami/async-tree": "0.0.49",
+    "@weborigami/language": "0.0.49",
+    "@weborigami/types": "0.0.49",
     "exif-parser": "0.1.12",
-    "graphviz-wasm": "3.0.1",
+    "graphviz-wasm": "3.0.2",
     "highlight.js": "11.9.0",
-    "marked": "12.0.1",
+    "marked": "12.0.2",
     "marked-gfm-heading-id": "3.1.3",
     "marked-highlight": "2.1.1",
     "marked-smartypants": "1.1.6",
-    "sharp": "0.33.2",
-    "yaml": "2.4.1"
+    "sharp": "0.33.3",
+    "yaml": "2.4.2"
   },
   "scripts": {
     "build": "ori exports/buildExports.js src > exports/exports.js",

package/src/builtins/@addNextPrevious.js

@@ -0,0 +1,47 @@
+import { Tree } from "@weborigami/async-tree";
+import getTreeArgument from "../misc/getTreeArgument.js";
+
+/**
+ * Add nextKey/previousKey properties to values.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @this {AsyncTree|null}
+ * @param {import("@weborigami/async-tree").Treelike} treelike
+ */
+export default async function sequence(treelike) {
+  const tree = await getTreeArgument(this, arguments, treelike, "@sequence");
+  let keys;
+  return Object.create(tree, {
+    get: {
+      value: async (key) => {
+        let value = await tree.get(key);
+
+        if (Tree.isTreelike(value)) {
+          value = await Tree.plain(value);
+        } else if (typeof value === "object") {
+          // Clone value to avoid modifying the original object.
+          value = { ...value };
+        } else {
+          return value;
+        }
+
+        if (keys === undefined) {
+          keys = Array.from(await tree.keys());
+        }
+        const index = keys.indexOf(key);
+        if (index === -1) {
+          // Key is supported but not published in `keys`
+          return value;
+        }
+
+        // Extend value with nextKey/previousKey properties.
+        return Object.assign(value, {
+          nextKey: keys[index + 1],
+          previousKey: keys[index - 1],
+        });
+      },
+      writable: true,
+    },
+  });
+}

package/src/builtins/@debug.js

@@ -1,4 +1,4 @@
-import { Tree, isPlainObject } from "@weborigami/async-tree";
+import { Tree } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 import ExplorableSiteTransform from "../common/ExplorableSiteTransform.js";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
@@ -19,12 +19,13 @@ export default async function debug(treelike) {
   // apply its own scope to the tree.
   let tree = await getTreeArgument(this, arguments, treelike, "@debug");
 
+  if (!isTransformApplied(DebugTransform, tree)) {
+    tree = transformObject(DebugTransform, tree);
+  }
   if (!isTransformApplied(ExplorableSiteTransform, tree)) {
     tree = transformObject(ExplorableSiteTransform, tree);
   }
 
-  tree = transformObject(DebugTransform, tree);
-
   return tree;
 }
 
@@ -36,20 +37,19 @@ function DebugTransform(Base) {
   return class Debug extends OriCommandTransform(Base) {
     async get(key) {
       let value = await super.get(key);
+      const scope = Scope.getScope(this);
 
-      // Since this transform is for diagnostic purposes, cast arrays
-      // or plain objects to trees so we can debug them too.
-      if (value instanceof Array || isPlainObject(value)) {
+      // Since this transform is for diagnostic purposes, cast any treelike
+      // result to a tree so we can debug the result too.
+      if (Tree.isTreelike(value)) {
         value = Tree.from(value);
-      }
-
-      // Ensure debug transforms are applied to explorable results.
-      if (Tree.isAsyncTree(value)) {
-        value = transformObject(ExplorableSiteTransform, value);
-        value = transformObject(DebugTransform, value);
-      }
-
-      if (value?.unpack) {
+        if (!value.parent && !value.scope) {
+          value = Scope.treeWithScope(value, scope);
+        }
+        if (!isTransformApplied(DebugTransform, value)) {
+          value = transformObject(DebugTransform, value);
+        }
+      } else if (value?.unpack) {
         // If the value isn't a tree, but has a tree attached via an `unpack`
         // method, wrap the unpack method to provide debug support for it.
         const original = value.unpack.bind(value);
@@ -61,13 +61,11 @@ function DebugTransform(Base) {
           /** @type {any} */
           let tree = Tree.from(content);
           if (!tree.parent && !tree.scope) {
-            const scope = Scope.getScope(this);
             tree = Scope.treeWithScope(tree, scope);
           }
-          if (!isTransformApplied(ExplorableSiteTransform, tree)) {
-            tree = transformObject(ExplorableSiteTransform, tree);
+          if (!isTransformApplied(DebugTransform, tree)) {
+            tree = transformObject(DebugTransform, tree);
           }
-          tree = transformObject(DebugTransform, tree);
           return tree;
         };
       }

package/src/builtins/@document.js

@@ -8,9 +8,8 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @this {AsyncTree|null}
  * @param {StringLike} text
  * @param {any} [data]
- * @returns
  */
-export default function documentBuiltin(text, data) {
+export default async function documentBuiltin(text, data) {
   assertScopeIsDefined(this, "document");
   return documentObject(text, data);
 }

package/src/builtins/@inline.js

@@ -1,4 +1,4 @@
-import { isUnpackable, symbols } from "@weborigami/async-tree";
+import { ObjectTree, isUnpackable, symbols } from "@weborigami/async-tree";
 import { compile } from "@weborigami/language";
 import documentObject from "../common/documentObject.js";
 import { toString } from "../common/utilities.js";
@@ -24,7 +24,13 @@ export default async function inline(input) {
   }
   const inputIsDocument = input["@text"] !== undefined;
   const origami = inputIsDocument ? input["@text"] : toString(input);
-  const parent = input.parent ?? input[symbols.parent];
+
+  let parent = /** @type {any} */ (input).parent ?? input[symbols.parent];
+  if (!parent) {
+    // Construct a temporary parent that has the right scope.
+    parent = new ObjectTree({});
+    parent.scope = this;
+  }
 
   // If the input document is a plain object, include it in scope for the
   // evaluated expression.

package/src/builtins/@makeParser.js

@@ -0,0 +1,9 @@
+const parsers = {};
+
+export default function makeParser(text) {
+  if (!parsers[text]) {
+    const regexp = new RegExp(text);
+    parsers[text] = (input) => input.match(regexp)?.groups;
+  }
+  return parsers[text];
+}

package/src/builtins/@map.js

@@ -1,11 +1,13 @@
 import {
   cachedKeyFunctions,
+  isPlainObject,
   keyFunctionsForExtensions,
   map,
 } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 import addValueKeyToScope from "../common/addValueKeyToScope.js";
 import { toFunction } from "../common/utilities.js";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 
 /**
  * Map a hierarchical tree of keys and values to a new tree of keys and values.
@@ -14,38 +16,41 @@ import { toFunction } from "../common/utilities.js";
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
  * @typedef {import("@weborigami/async-tree").TreeTransform} TreeTransform
- * @typedef {import("../../index.ts").TreelikeTransform} TreelikeTransform
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  *
  * @typedef {{ deep?: boolean, description?: string, extension?: string,
  * extensions?: string, inverseKey?: KeyFn, key?: ValueKeyFn, keyMap?:
- * ValueKeyFn, value?: ValueKeyFn, valueFn?: ValueKeyFn }} TreeMapOptions
+ * ValueKeyFn, needsSourceValue?: boolean, value?: ValueKeyFn, valueMap?:
+ * ValueKeyFn }} MapOptionsDictionary
  *
- * @this {import("@weborigami/types").AsyncTree|null}
+ * @typedef {ValueKeyFn|MapOptionsDictionary} OptionsOrValueFn
  *
  * @overload
- * @param {ValueKeyFn} param1
- * @returns {TreelikeTransform}
- *
- * @overload
- * @param {TreeMapOptions} param1
- * @returns {TreelikeTransform}
- *
- * @overload
- * @param {Treelike} param1
- * @param {ValueKeyFn} param2
+ * @param {Treelike} source
+ * @param {OptionsOrValueFn} instructions
  * @returns {AsyncTree}
  *
  * @overload
- * @param {Treelike} param1
- * @param {TreeMapOptions} param2
- * @returns {AsyncTree}
+ * @param {OptionsOrValueFn} instructions
+ * @returns {TreeTransform}
+ *
+ * @this {AsyncTree|null}
+ * @param {Treelike|OptionsOrValueFn} param1
+ * @param {OptionsOrValueFn} [param2]
  */
 export default function treeMap(param1, param2) {
-  // Identify whether the valueFn/options are the first parameter
-  // or the second.
+  assertScopeIsDefined(this, "map");
+
+  // Identify whether the map instructions are in the first parameter or the
+  // second. If present, identify the function to apply to values.
+
+  /** @type {Treelike|undefined} */
   let source;
-  let options;
+  /** @type {OptionsOrValueFn} */
+  let instructions;
+  /** @type {ValueKeyFn|undefined} */
+  let valueFn;
+
   if (arguments.length === 0) {
     throw new TypeError(
       `@map: You must give @map a function or a dictionary of options.`
@@ -53,29 +58,35 @@ export default function treeMap(param1, param2) {
   } else if (!param1) {
     throw new TypeError(`@map: The first argument was undefined.`);
   } else if (arguments.length === 1) {
-    options = param1;
-  } else if (!param2) {
+    // One argument
+    // @ts-ignore
+    instructions = param1;
+  } else if (param2 === undefined) {
     throw new TypeError(`@map: The second argument was undefined.`);
   } else {
+    // Two arguments
     source = param1;
-    options = param2;
+    instructions = param2;
   }
 
-  // Identify whether the valueFn/options is a valueFn function
-  // or an options dictionary.
-  let valueFn;
-  if (
-    typeof options === "function" ||
-    typeof (/** @type {any} */ (options)?.unpack) === "function"
+  // Identify whether the map instructions take the form of a value function or
+  // a dictionary of options.
+  /** @type {MapOptionsDictionary} */
+  let options;
+  if (isPlainObject(instructions)) {
+    // @ts-ignore
+    options = instructions;
+    valueFn = options?.value ?? options?.valueMap;
+  } else if (
+    typeof instructions === "function" ||
+    typeof (/** @type {any} */ (instructions)?.unpack) === "function"
   ) {
-    valueFn = options;
+    valueFn = instructions;
     options = {};
-  } else if (!options) {
+  } else {
     throw new TypeError(
       `@map: You must specify a value function or options dictionary.`
     );
-  } else {
-    valueFn = options.value ?? options.valueMap;
   }
 
   let { deep, description, inverseKey, needsSourceValue } = options;
@@ -131,8 +142,8 @@ export default function treeMap(param1, param2) {
     extendedInverseKeyFn = keyFns.inverseKey;
   } else {
     // Use sidecar keyFn/inverseKey functions if the valueFn defines them.
-    extendedKeyFn = valueFn?.key;
-    extendedInverseKeyFn = valueFn?.inverseKey;
+    extendedKeyFn = /** @type {any} */ (valueFn)?.key;
+    extendedInverseKeyFn = /** @type {any} */ (valueFn)?.inverseKey;
   }
 
   const transform = function mapTreelike(treelike) {

package/src/builtins/@mapDeep.js

@@ -1,22 +1,71 @@
 import { isPlainObject } from "@weborigami/async-tree";
+import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
 import treeMap from "./@map.js";
 
+/**
+ * Map a hierarchical tree of keys and values to a new tree of keys and values.
+ *
+ * @typedef {import("@weborigami/async-tree").KeyFn} KeyFn
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/async-tree").ValueKeyFn} ValueKeyFn
+ * @typedef {import("@weborigami/async-tree").TreeTransform} TreeTransform
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ *
+ * @typedef {{ deep?: boolean, description?: string, extension?: string,
+ * extensions?: string, inverseKey?: KeyFn, key?: ValueKeyFn, keyMap?:
+ * ValueKeyFn, needsSourceValue?: boolean, value?: ValueKeyFn, valueMap?:
+ * ValueKeyFn }} MapOptionsDictionary
+ *
+ * @typedef {ValueKeyFn|MapOptionsDictionary} OptionsOrValueFn
+ *
+ * @overload
+ * @param {Treelike} source
+ * @param {OptionsOrValueFn} instructions
+ * @returns {AsyncTree}
+ *
+ * @overload
+ * @param {OptionsOrValueFn} instructions
+ * @returns {TreeTransform}
+ *
+ * @this {AsyncTree|null}
+ * @param {Treelike|OptionsOrValueFn} param1
+ * @param {OptionsOrValueFn} [param2]
+ */
 export default function mapDeep(param1, param2) {
-  // Identify whether the valueFn/options are the first parameter
-  // or the second.
-  let source;
-  let options;
-  if (param2 === undefined) {
-    options = param1;
+  assertScopeIsDefined(this, "mapDeep");
+
+  // Identify whether the map instructions are the first parameter or the
+  // second.
+  if (arguments.length === 1) {
+    // One argument, which is a dictionary or function.
+    /** @type {MapOptionsDictionary} */
+    const options = isPlainObject(param1)
+      ? // Dictionary
+        { ...param1, deep: true }
+      : // Function
+        { deep: true, value: param1 };
+    const transform = treeMap.call(this, options);
+    return transform;
   } else {
-    source = param1;
-    if (isPlainObject(param2)) {
-      options = param2;
-    } else {
-      options = { value: param2 };
-    }
-  }
+    // Two arguments, second is a dictionary or function.
+    /** @type {Treelike} */
+    const source = param1;
+    /** @type {MapOptionsDictionary} */
+    const options = isPlainObject(param2)
+      ? // Dictionary
+        { ...param2, deep: true }
+      : // Function
+        { deep: true, value: param2 };
 
-  options.deep = true;
-  return treeMap(source, options);
+    // We go through some type gymnastics to convince TypeScript that the return
+    // value is an AsyncTree. Using `.call()` with the overloaded `@map`
+    // function seems to confuse TypeScript into thinking the call will return a
+    // TreeTransform.
+
+    /** @type {AsyncTree} */
+    let tree;
+    // @ts-ignore
+    tree = treeMap.call(this, source, options);
+    return tree;
+  }
 }

package/src/builtins/@ori.js

@@ -62,7 +62,7 @@ async function formatResult(result) {
   } else if (
     !(result instanceof Array) &&
     (typeof result !== "object" ||
-      result.toString !== getRealmObjectPrototype(result).toString)
+      result.toString !== getRealmObjectPrototype(result)?.toString)
   ) {
     text = result.toString();
   } else if (typeof result === "object") {

package/src/builtins/@parse/json.js

@@ -1,4 +1,7 @@
-export default async function parseJson(text) {
+import { toString } from "../../common/utilities.js";
+
+export default async function parseJson(input) {
+  const text = toString(input);
   return text ? JSON.parse(text) : undefined;
 }
 

package/src/builtins/@parse/yaml.js

@@ -1,7 +1,9 @@
 import * as serialize from "../../common/serialize.js";
+import { toString } from "../../common/utilities.js";
 
-export default async function parseYaml(text) {
-  return text ? serialize.parseYaml(String(text)) : undefined;
+export default async function parseYaml(input) {
+  const text = toString(input);
+  return text ? serialize.parseYaml(text) : undefined;
 }
 
 parseYaml.usage = `parseYaml <text>\tParse text as YAML (including JSON)`;

package/src/builtins/@perf.js

@@ -7,7 +7,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @this {import("@weborigami/types").AsyncTree|null}
  * @param {Function} fn
  */
-export default async function perf(fn, count = 10000) {
+export default async function perf(fn, count = 1) {
   assertScopeIsDefined(this, "perf");
   const start = performance.now();
   for (let i = 0; i < count; i++) {

package/src/builtins/@rss.js

@@ -24,7 +24,7 @@ export default async function rss(jsonFeedTree) {
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
   <channel>
     <atom:link href="${rssUrl}" rel="self" type="application/rss+xml"/>
-    <title>${title}</title>
+    <title><![CDATA[${title}]]></title>
     <link>${home_page_url}</link>
     <description>${description}</description>
 ${itemsRss}</channel>
@@ -33,15 +33,19 @@ ${itemsRss}</channel>
 
 function itemRss(jsonFeedItem) {
   const { content_html, date_published, id, title, url } = jsonFeedItem;
-  // RSS wants dates in RFC-822.
-  const date = date_published?.toUTCString() ?? null;
+  // RSS wants dates in RFC-822, essentially the same as ISO 8601.
+  const date =
+    date_published instanceof Date
+      ? date_published.toUTCString()
+      : date_published;
   const dateElement = date ? `      <pubDate>${date}</pubDate>\n` : "";
   const guidElement = id ? `      <guid>${id}</guid>\n` : "";
   const contentElement = content_html
     ? `      <description><![CDATA[${content_html}]]></description>\n`
     : "";
+  const titleElement = `<![CDATA[${title}]]>`;
   return `    <item>
-${dateElement}      <title>${title}</title>
+${dateElement}      <title>${titleElement}</title>
       <link>${url}</link>
 ${guidElement}${contentElement}    </item>
 `;

package/src/builtins/@slug.js

@@ -0,0 +1,15 @@
+export default function slug(filename) {
+  let slug = filename.toLowerCase();
+
+  // Convert spaces to dashes
+  slug = slug.replace(/\s+/g, "-");
+
+  // Remove special characters except dashes, letters, numbers, and periods.
+  slug = slug.replace(/[^\w\-\.]/g, "");
+
+  // Trim leading or trailing dashes.
+  slug = slug.replace(/^-+/, "");
+  slug = slug.replace(/-+$/, "");
+
+  return slug;
+}

package/src/builtins/map.d.ts

@@ -1,6 +1,5 @@
-import { KeyFn, Treelike, ValueKeyFn } from "@weborigami/async-tree";
+import { KeyFn, Treelike, TreeTransform, ValueKeyFn } from "@weborigami/async-tree";
 import { AsyncTree } from "@weborigami/types";
-import { TreelikeTransform } from "../../index.ts";
 
 type TreeMapOptions = {
   deep?: boolean;
@@ -8,10 +7,10 @@ type TreeMapOptions = {
   extensions?: string;
   inverseKey?: KeyFn;
   key?: ValueKeyFn;
+  needsSourceValue?: boolean;
   value?: ValueKeyFn;
 };
 
-export default function treeMap(value: ValueKeyFn): TreelikeTransform;
-export default function treeMap(options: TreeMapOptions): TreelikeTransform;
-export default function treeMap(treelike: Treelike, value: ValueKeyFn): AsyncTree;
-export default function treeMap(treelike: Treelike, options: TreeMapOptions): AsyncTree;
+export default function treeMap(options: ValueKeyFn | TreeMapOptions): TreeTransform;
+export default function treeMap(treelike: Treelike, options: ValueKeyFn | TreeMapOptions): AsyncTree;
+export default function treeMap(param1: Treelike | ValueKeyFn | TreeMapOptions, param2?: ValueKeyFn | TreeMapOptions): AsyncTree | TreeTransform;

package/src/common/ExplorableSiteTransform.js

@@ -1,7 +1,7 @@
 import { Tree, keysJson } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 import index from "../builtins/@index.js";
-import { transformObject } from "../common/utilities.js";
+import { isTransformApplied, transformObject } from "../common/utilities.js";
 
 /**
  * Wraps a tree (typically a SiteTree) to turn a standard site into an
@@ -33,10 +33,10 @@ export default function ExplorableSiteTransform(Base) {
 
       // Ask the tree if it has the key.
       let value = await super.get(key);
+      const scope = Scope.getScope(this);
 
       if (value === undefined) {
         // The tree doesn't have the key; try the defaults.
-        const scope = Scope.getScope(this);
         if (scope) {
           if (key === "index.html") {
             value = await index.call(scope, this);
@@ -46,15 +46,19 @@ export default function ExplorableSiteTransform(Base) {
         }
       }
 
-      // Ensure this transform is applied to any explorable result. This lets
-      // the user browse into data and explorable trees of types other than the
-      // current class.
       if (Tree.isAsyncTree(value)) {
-        value = transformObject(ExplorableSiteTransform, value);
-      }
+        // Ensure this transform is applied to any tree result so the user
+        // browse into data and trees of classes other than the current class.
+        if (!isTransformApplied(ExplorableSiteTransform, value)) {
+          value = transformObject(ExplorableSiteTransform, value);
+        }
 
-      if (value?.unpack) {
-        // If the value isn't a tree, but has a tree attached via a `unpack`
+        if (key.endsWith?.("/")) {
+          // Instead of return the tree directly, return an index for it.
+          value = await index.call(scope, value);
+        }
+      } else if (value?.unpack) {
+        // If the value isn't a tree, but has a tree attached via an `unpack`
         // method, wrap the unpack method to add this transform.
         const original = value.unpack.bind(value);
         value.unpack = async () => {
@@ -68,7 +72,9 @@ export default function ExplorableSiteTransform(Base) {
             const scope = Scope.getScope(this);
             tree = Scope.treeWithScope(tree, scope);
           }
-          tree = transformObject(ExplorableSiteTransform, tree);
+          if (!isTransformApplied(ExplorableSiteTransform, tree)) {
+            tree = transformObject(ExplorableSiteTransform, tree);
+          }
           return tree;
         };
       }

package/src/common/documentObject.js

@@ -1,5 +1,5 @@
-import { isPlainObject } from "@weborigami/async-tree";
-import txtHandler from "../builtins/txt_handler.js";
+import { isPlainObject, isUnpackable } from "@weborigami/async-tree";
+// import txtHandler from "../builtins/txt_handler.js";
 
 /**
  * In Origami, a text document object is any object with a `@text` property and
@@ -12,9 +12,15 @@ import txtHandler from "../builtins/txt_handler.js";
  * @param {StringLike|PlainObject} input
  * @param {any} [data]
  */
-export default function documentObject(input, data) {
+export default async function documentObject(input, data) {
   let text;
   let inputData;
+
+  if (isUnpackable(input)) {
+    // Unpack the input first, might already be a document object.
+    input = await input.unpack();
+  }
+
   if (isPlainObject(input)) {
     text = input["@text"];
     inputData = input;
@@ -22,12 +28,15 @@ export default function documentObject(input, data) {
     text = String(input);
     inputData = null;
   }
-  const base = {
-    pack() {
-      return txtHandler.pack(this);
-    },
-  };
-  const result = Object.create(base);
+  // TODO: Either restore this code, or move responsibility for packing a
+  // document to HandleExtensionsTransform set().
+  // const base = {
+  //   pack() {
+  //     return txtHandler.pack(this);
+  //   },
+  // };
+  // const result = Object.create(base);
+  const result = {};
   Object.assign(result, inputData, data, { "@text": text });
   return result;
 }

package/src/common/utilities.js

@@ -45,10 +45,13 @@ export const keySymbol = Symbol("key");
  * @param {string} resultExtension
  */
 export function replaceExtension(key, sourceExtension, resultExtension) {
-  if (!key.endsWith(sourceExtension)) {
+  if (!key) {
+    return undefined;
+  } else if (!key.endsWith(sourceExtension)) {
     return key;
+  } else {
+    return key.slice(0, -sourceExtension.length) + resultExtension;
   }
-  return key.slice(0, -sourceExtension.length) + resultExtension;
 }
 
 /**

package/src/misc/OriCommandTransform.js

@@ -1,8 +1,8 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { ObjectTree, Tree } from "@weborigami/async-tree";
+import { ObjectTree } from "@weborigami/async-tree";
 import { Scope } from "@weborigami/language";
 import ori from "../builtins/@ori.js";
-import { keySymbol, transformObject } from "../common/utilities.js";
+import { keySymbol } from "../common/utilities.js";
 
 /**
  * Add support for commands prefixed with `!`.
@@ -34,11 +34,6 @@ export default function OriCommandTransform(Base) {
         const extendedScope = new Scope(ambientsTree, Scope.getScope(this));
         const source = key.slice(1).trim();
         value = await ori.call(extendedScope, source, { formatResult: false });
-
-        // Ensure this transform is applied to any subtree.
-        if (Tree.isAsyncTree(value)) {
-          value = transformObject(OriCommandTransform, value);
-        }
       }
 
       return value;

package/src/server/constructResponse.js

@@ -25,7 +25,7 @@ export default async function constructResponse(request, resource) {
   if (resource instanceof Response) {
     // Already a Response, return as is.
     return resource;
-  } else if (!resource) {
+  } else if (resource == null) {
     return null;
   }
 
@@ -42,14 +42,8 @@ export default async function constructResponse(request, resource) {
     mediaType = extension ? mediaTypeForExtension[extension] : undefined;
   }
 
-  if (
-    mediaType === undefined &&
-    !url.pathname.endsWith("/") &&
-    (Tree.isAsyncTree(resource) ||
-      isPlainObject(resource) ||
-      resource instanceof Array)
-  ) {
-    // Redirect to an index page for the result.
+  if (!url.pathname.endsWith("/") && Tree.isTreelike(resource)) {
+    // Treelike resource: redirect to its index page.
     const Location = `${request.url}/`;
     return new Response("ok", {
       headers: {

package/src/server/server.js

@@ -120,8 +120,11 @@ function keysFromUrl(url) {
     pathKeys[pathKeys.length - 1] = "index.html";
   }
 
-  // Add back the `!` to commands.
-  const commandKeys = parts.map((command) => `!${command}`);
+  // Decode the text of the commands, prefix spaces with a backslash, and add
+  // back the `!` character.
+  const commandKeys = parts.map(
+    (command) => `!${decodeURIComponent(command).replace(/ /g, "\\ ")}`
+  );
 
   const keys = [...pathKeys, ...commandKeys];
   return keys;