@weborigami/origami 0.0.65 → 0.0.66-beta.2

package/exports/PathTransform.js

@@ -1,3 +1,5 @@
+import { trailingSlash } from "@weborigami/async-tree";
+
 export default function PathTransform(Base) {
   return class Path extends Base {
     async get(key) {
@@ -6,7 +8,7 @@ export default function PathTransform(Base) {
         // @ts-ignore
         const path = this[PathTransform.pathKey]
           ? // @ts-ignore
-            `${this[PathTransform.pathKey]}/${key}`
+            `${trailingSlash.add(this[PathTransform.pathKey])}${key}`
           : key;
         value[PathTransform.pathKey] = path;
       }

package/exports/exports.js

@@ -72,6 +72,7 @@ export { default as paginateFn } from "../src/builtins/@paginateFn.js";
 export { default as parent } from "../src/builtins/@parent.js";
 export { default as perf } from "../src/builtins/@perf.js";
 export { default as plain } from "../src/builtins/@plain.js";
+export { default as post } from "../src/builtins/@post.js";
 export { default as project } from "../src/builtins/@project.js";
 export { default as redirect } from "../src/builtins/@redirect.js";
 export { default as regexMatch } from "../src/builtins/@regexMatch.js";
@@ -84,6 +85,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 * from "../src/builtins/@slash.js";
 export { default as slug } from "../src/builtins/@slug.js";
 export { default as sort } from "../src/builtins/@sort.js";
 export { default as sortFn } from "../src/builtins/@sortFn.js";
@@ -139,4 +141,5 @@ export { default as origamiHighlightDefinition } from "../src/misc/origamiHighli
 export { default as treeDot } from "../src/misc/treeDot.js";
 export { default as constructResponse } from "../src/server/constructResponse.js";
 export * from "../src/server/mediaTypes.js";
+export { default as parsePostData } from "../src/server/parsePostData.js";
 export * from "../src/server/server.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/origami",
-  "version": "0.0.65",
+  "version": "0.0.66-beta.2",
   "description": "Web Origami language, CLI, framework, and server",
   "type": "module",
   "repository": {
@@ -13,17 +13,17 @@
   "main": "./exports/exports.js",
   "types": "./index.ts",
   "devDependencies": {
-    "@types/node": "22.5.4",
-    "typescript": "5.5.4"
+    "@types/node": "22.7.4",
+    "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.0.65",
-    "@weborigami/language": "0.0.65",
-    "@weborigami/types": "0.0.65",
+    "@weborigami/async-tree": "0.0.66-beta.2",
+    "@weborigami/language": "0.0.66-beta.2",
+    "@weborigami/types": "0.0.66-beta.2",
     "exif-parser": "0.1.12",
     "graphviz-wasm": "3.0.2",
     "highlight.js": "11.10.0",
-    "marked": "14.1.1",
+    "marked": "14.1.2",
     "marked-gfm-heading-id": "4.1.0",
     "marked-highlight": "2.1.4",
     "marked-smartypants": "1.1.8",

package/src/builtins/@cache.js

@@ -19,7 +19,9 @@ export default async function cacheBuiltin(
 ) {
   assertTreeIsDefined(this, "cache");
   /** @type {any} */
-  const cacheTree = cacheTreelike ? Tree.from(cacheTreelike) : undefined;
+  const cacheTree = cacheTreelike
+    ? Tree.from(cacheTreelike, { parent: this })
+    : undefined;
   const result = cache(sourceTreelike, cacheTree, filterTreelike);
   return result;
 }

package/src/builtins/@changes.js

@@ -1,10 +1,18 @@
 import { Tree } from "@weborigami/async-tree";
 
-// Given an old tree and a new tree, return a tree of changes indicated
-// by the values: "added", "changed", or "deleted".
+/**
+ * Given an old tree and a new tree, return a tree of changes indicated
+ * by the values: "added", "changed", or "deleted".
+ *
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {Treelike} oldTreelike
+ * @param {Treelike} newTreelike
+ */
 export default async function changes(oldTreelike, newTreelike) {
-  const oldTree = Tree.from(oldTreelike, { deep: true });
-  const newTree = Tree.from(newTreelike, { deep: true });
+  const oldTree = Tree.from(oldTreelike, { deep: true, parent: this });
+  const newTree = Tree.from(newTreelike, { deep: true, parent: this });
 
   const oldKeys = Array.from(await oldTree.keys());
   const newKeys = Array.from(await newTree.keys());
@@ -21,7 +29,7 @@ export default async function changes(oldTreelike, newTreelike) {
     const newValue = await newTree.get(key);
 
     if (Tree.isAsyncTree(oldValue) && Tree.isAsyncTree(newValue)) {
-      const treeChanges = await changes(oldValue, newValue);
+      const treeChanges = await changes.call(this, oldValue, newValue);
       if (Object.keys(treeChanges).length > 0) {
         result[key] = treeChanges;
       }

package/src/builtins/@concat.js

@@ -12,7 +12,7 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  */
 export default async function concat(...args) {
   assertTreeIsDefined(this, "concat");
-  const tree = args.length === 0 ? this : Tree.from(args);
+  const tree = args.length === 0 ? this : Tree.from(args, { parent: this });
   return ops.concat.call(this, tree);
 }
 

package/src/builtins/@copy.js

@@ -16,8 +16,8 @@ import setDeep from "./@setDeep.js";
 export default async function copy(source, target) {
   assertTreeIsDefined(this, "copy");
   // const start = performance.now();
-  const sourceTree = Tree.from(source);
-  /** @type {any} */ let targetTree = Tree.from(target);
+  const sourceTree = Tree.from(source, { parent: this });
+  /** @type {any} */ let targetTree = Tree.from(target, { parent: this });
 
   if (stdout.isTTY) {
     targetTree = transformObject(ProgressTransform, targetTree);
@@ -26,7 +26,7 @@ export default async function copy(source, target) {
     countCopied = 0;
   }
 
-  await setDeep(targetTree, sourceTree);
+  await setDeep.call(this, targetTree, sourceTree);
 
   if (stdout.isTTY) {
     process.stdout.clearLine(0);

package/src/builtins/@crawl.js

@@ -4,6 +4,7 @@ import {
   deepMerge,
   isPlainObject,
   keysFromPath,
+  trailingSlash,
 } from "@weborigami/async-tree";
 import { InvokeFunctionsTransform, extname } from "@weborigami/language";
 import * as utilities from "../common/utilities.js";
@@ -34,7 +35,7 @@ export default async function crawl(treelike, baseHref) {
   const tree =
     typeof treelike === "string"
       ? treeHttps.call(this, treelike)
-      : Tree.from(treelike);
+      : Tree.from(treelike, { parent: this });
 
   if (baseHref === undefined) {
     // Ask tree or original treelike if it has an `href` property we can use as
@@ -75,7 +76,7 @@ export default async function crawl(treelike, baseHref) {
     for (const resourcePath of resourcePaths) {
       const resourceKeys = adjustKeys(keysFromPath(resourcePath));
       const fn = () => {
-        return traverse(tree, ...resourceKeys);
+        return Tree.traverse(tree, ...resourceKeys);
       };
       addValueToObject(resources, resourceKeys, fn);
     }
@@ -100,18 +101,19 @@ export default async function crawl(treelike, baseHref) {
 }
 
 // For indexing and storage purposes, treat a path that ends in a trailing slash
-// (or the dot we use to seed the queue) as if it ends in index.html.
+// as if it ends in index.html.
 function adjustKeys(keys) {
-  const adjustedKeys = keys.slice();
-  if (adjustedKeys.at(-1) === "") {
-    adjustedKeys[adjustedKeys.length - 1] = "index.html";
+  if (keys.length > 0 && !trailingSlash.has(keys.at(-1))) {
+    return keys;
   }
+  const adjustedKeys = keys.slice();
+  adjustedKeys.push("index.html");
   return adjustedKeys;
 }
 
 function addValueToObject(object, keys, value) {
   for (let i = 0, current = object; i < keys.length; i++) {
-    const key = keys[i];
+    const key = trailingSlash.remove(keys[i]);
     if (i === keys.length - 1) {
       // Write out value
       if (isPlainObject(current[key])) {
@@ -150,7 +152,7 @@ async function* crawlPaths(tree, baseUrl) {
   const promisesForPaths = {};
 
   // Seed the promise dictionary with robots.txt and the root path.
-  const initialPaths = ["/robots.txt", ""];
+  const initialPaths = ["/robots.txt", "/"];
   initialPaths.forEach((path) => {
     promisesForPaths[path] = processPath(tree, path, baseUrl);
   });
@@ -468,14 +470,13 @@ async function processPath(tree, path, baseUrl) {
   }
 
   // Convert path to keys
-  /** @type {any[]} */
-  let keys = path === "" ? [""] : keysFromPath(path);
+  const keys = keysFromPath(path);
 
   // Traverse tree to get value.
-  let value = await traverse(tree, ...keys);
+  let value = await Tree.traverse(tree, ...keys);
   if (Tree.isAsyncTree(value)) {
     // Path is actually a directory; see if it has an index.html
-    value = await traverse(value, "index.html");
+    value = await Tree.traverse(value, "index.html");
   }
 
   const adjustedKeys = adjustKeys(keys);
@@ -508,18 +509,5 @@ async function processPath(tree, path, baseUrl) {
   };
 }
 
-async function traverse(tree, ...keys) {
-  if (tree.resolve && keys.length > 1) {
-    // Tree like SiteTree that supports resolve() method
-    const lastKey = keys.pop();
-    const path = keys.join("/");
-    const resolved = tree.resolve(path);
-    return resolved.get(lastKey);
-  } else {
-    // Regular async tree
-    return Tree.traverse(tree, ...keys);
-  }
-}
-
 crawl.usage = `@crawl <tree>\tCrawl a tree`;
 crawl.documentation = "https://weborigami.org/language/@crawl.html";

package/src/builtins/@debug.js

@@ -39,12 +39,11 @@ function DebugTransform(Base) {
       const parent = this;
 
       // 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);
-        if (!value.parent) {
-          value.parent = parent;
-        }
+      // result to a tree so we can debug the result too. (Don't do this for
+      // functions, as that can be undesirable, e.g., when writing functions
+      // that handle POST requests.)
+      if (Tree.isTreelike(value) && typeof value !== "function") {
+        value = Tree.from(value, { parent });
         if (!isTransformApplied(DebugTransform, value)) {
           value = transformObject(DebugTransform, value);
         }
@@ -58,10 +57,7 @@ function DebugTransform(Base) {
             return content;
           }
           /** @type {any} */
-          let tree = Tree.from(content);
-          if (!tree.parent) {
-            tree.parent = parent;
-          }
+          let tree = Tree.from(content, { parent });
           if (!isTransformApplied(DebugTransform, tree)) {
             tree = transformObject(DebugTransform, tree);
           }

package/src/builtins/@filter.js

@@ -1,3 +1,4 @@
+import { Tree } from "@weborigami/async-tree";
 import FilterTree from "../common/FilterTree.js";
 import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
@@ -7,12 +8,15 @@ import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @this {AsyncTree|null}
- * @param {Treelike} treelike
- * @param {Treelike} filterVariant
+ * @param {Treelike} sourceTreelike
+ * @param {Treelike} filterTreelike
  */
-export default async function filter(treelike, filterVariant) {
+export default async function filter(sourceTreelike, filterTreelike) {
   assertTreeIsDefined(this, "filter");
-  const result = new FilterTree(treelike, filterVariant);
+  const sourceTree = Tree.from(sourceTreelike, { parent: this });
+  const filterTree = Tree.from(filterTreelike, { deep: true, parent: this });
+  const result = new FilterTree(sourceTree, filterTree);
+  result.parent = this;
   return result;
 }
 

package/src/builtins/@inners.js

@@ -1,8 +1,9 @@
-import { Tree } from "@weborigami/async-tree";
+import { trailingSlash, Tree } from "@weborigami/async-tree";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
- * Return the source nodes of the tree: the nodes with children.
+ * Return the interior nodes of the tree. This relies on subtree keys having
+ * trailing slashes.
  *
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
@@ -19,12 +20,8 @@ export default async function inners(treelike) {
     },
 
     async keys() {
-      const subtreeKeys = [];
-      for (const key of await tree.keys()) {
-        if (await Tree.isKeyForSubtree(tree, key)) {
-          subtreeKeys.push(key);
-        }
-      }
+      const keys = [...(await tree.keys())];
+      const subtreeKeys = keys.filter(trailingSlash.has);
       return subtreeKeys;
     },
   };
@@ -32,5 +29,5 @@ export default async function inners(treelike) {
   return result;
 }
 
-inners.usage = `@inners <tree>\tThe source nodes of the tree`;
+inners.usage = `@inners <tree>\tThe interior nodes of the tree`;
 inners.documentation = "https://weborigami.org/cli/builtins.html#inners";

package/src/builtins/@jsonKeys.js

@@ -28,7 +28,7 @@ function KeysJsonTransform(Base) {
       if (value === undefined && key === ".keys.json") {
         value = await jsonKeys.stringify(this);
       } else if (Tree.isTreelike(value)) {
-        const tree = Tree.from(value, { deep: true });
+        const tree = Tree.from(value, { deep: true, parent: this });
         value = transformObject(KeysJsonTransform, tree);
       }
       return value;

package/src/builtins/@mapFn.js

@@ -91,7 +91,7 @@ export default function mapFnBuiltin(operation) {
       );
       return resultKey;
     }
-    const keyFns = cachedKeyFunctions(scopedKeyFn);
+    const keyFns = cachedKeyFunctions(scopedKeyFn, deep);
     extendedKeyFn = keyFns.key;
     extendedInverseKeyFn = keyFns.inverseKey;
   } else {

package/src/builtins/@mdHtml.js

@@ -38,7 +38,7 @@ marked.use(
  * @param {StringLike|UnpackableStringlike} input
  */
 export default async function mdHtml(input) {
-  if (!input) {
+  if (input == null) {
     const error = new TypeError("@mdHtml: The input is not defined.");
     /** @type {any} */ (error).position = 0;
     throw error;

package/src/builtins/@paginateFn.js

@@ -11,11 +11,13 @@ import { Tree } from "@weborigami/async-tree";
  * @param {number} [size=10]
  */
 export default function paginateFn(size = 10) {
+  const parent = this;
+
   /**
    * @param {Treelike} [treelike]
    */
   return async function (treelike) {
-    const tree = Tree.from(treelike);
+    const tree = Tree.from(treelike, { parent });
     const keys = Array.from(await tree.keys());
     const pageCount = Math.ceil(keys.length / size);
 

package/src/builtins/@post.js

@@ -0,0 +1,45 @@
+import {
+  isStringLike,
+  isUnpackable,
+  toPlainValue,
+  toString,
+  Tree,
+} from "@weborigami/async-tree";
+
+/**
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {string} url
+ * @param {any} data
+ */
+export default async function post(url, data) {
+  let body;
+  let headers;
+  if (isUnpackable(data)) {
+    data = await data.unpack();
+  }
+  if (Tree.isTreelike(data)) {
+    const value = await toPlainValue(data);
+    body = JSON.stringify(value);
+    headers = {
+      "Content-Type": "application/json",
+    };
+  } else if (isStringLike(data)) {
+    body = toString(data);
+    headers = {
+      "Content-Type": "text/plain",
+    };
+  } else {
+    body = data;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    body,
+    headers,
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to POST to ${url}. Error ${response.status}: ${response.statusText}`
+    );
+  }
+  return response.arrayBuffer();
+}

package/src/builtins/@serve.js

@@ -25,10 +25,7 @@ export default async function serve(treelike, port) {
   assertTreeIsDefined(this, "serve");
   let tree;
   if (treelike) {
-    tree = Tree.from(treelike);
-
-    // TODO: Instead of applying ExplorableSiteTransform, apply a transform
-    // that just maps the empty string to index.html.
+    tree = Tree.from(treelike, { parent: this });
     if (!isTransformApplied(ExplorableSiteTransform, tree)) {
       tree = transformObject(ExplorableSiteTransform, tree);
     }

package/src/builtins/@setDeep.js

@@ -1,8 +1,15 @@
 import { Tree } from "@weborigami/async-tree";
 
+/**
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ *
+ * @this {import("@weborigami/types").AsyncTree|null}
+ * @param {Treelike} target
+ * @param {Treelike} source
+ */
 export default async function setDeep(target, source) {
-  const targetTree = Tree.from(target);
-  const sourceTree = Tree.from(source);
+  const targetTree = Tree.from(target, { parent: this });
+  const sourceTree = Tree.from(source, { parent: this });
   await applyUpdates(sourceTree, targetTree);
 }
 

package/src/builtins/@slash.js

@@ -0,0 +1 @@
+export { trailingSlash as default } from "@weborigami/async-tree";

package/src/builtins/@static.js

@@ -14,6 +14,7 @@ import index from "./@index.js";
 export default async function staticTree(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@static");
   const result = transformObject(StaticTransform, tree);
+  result.parent = this;
   return result;
 }
 
@@ -22,11 +23,12 @@ function StaticTransform(Base) {
     async get(key) {
       let value = await super.get(key);
       if (value === undefined && key === "index.html") {
-        value = index.call(this, this);
+        value = await index.call(this, this);
       } else if (value === undefined && key === ".keys.json") {
-        value = jsonKeys.stringify(this);
-      } else if (Tree.isAsyncTree(value)) {
-        value = transformObject(StaticTransform, value);
+        value = await jsonKeys.stringify(this);
+      } else if (Tree.isTreelike(value)) {
+        const tree = Tree.from(value, { parent: this });
+        value = transformObject(StaticTransform, tree);
       }
       return value;
     }

package/src/builtins/@watch.js

@@ -1,4 +1,5 @@
 import { Tree } from "@weborigami/async-tree";
+import { formatError } from "@weborigami/language";
 import ConstantTree from "../common/ConstantTree.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
@@ -42,16 +43,16 @@ export default async function watch(treelike, fn) {
   return handle;
 }
 
-async function evaluateTree(container, fn) {
+async function evaluateTree(parent, fn) {
   let tree;
   let message;
   let result;
   try {
-    result = await fn.call(container);
-  } catch (error) {
-    message = messageForError(error);
+    result = await fn.call(parent);
+  } catch (/** @type {any} */ error) {
+    message = formatError(error);
   }
-  tree = result ? Tree.from(result) : undefined;
+  tree = result ? Tree.from(result, { parent }) : undefined;
   if (tree) {
     return tree;
   }
@@ -60,33 +61,23 @@ async function evaluateTree(container, fn) {
   }
   console.warn(message);
   tree = new ConstantTree(message);
-  tree.parent = container;
+  tree.parent = parent;
   return tree;
 }
 
-function messageForError(error) {
-  let message = "";
-  // Work up to the root cause, displaying intermediate messages as we go up.
-  while (error.cause) {
-    message += error.message + `\n`;
-    error = error.cause;
-  }
-  if (error.name) {
-    message += `${error.name}: `;
-  }
-  message += error.message;
-  return message;
-}
-
 // Update an indirect pointer to a target.
 function updateIndirectPointer(indirect, target) {
   // Clean the pointer of any named properties or symbols that have been set
   // directly on it.
-  for (const key of Object.getOwnPropertyNames(indirect)) {
-    delete indirect[key];
-  }
-  for (const key of Object.getOwnPropertySymbols(indirect)) {
-    delete indirect[key];
+  try {
+    for (const key of Object.getOwnPropertyNames(indirect)) {
+      delete indirect[key];
+    }
+    for (const key of Object.getOwnPropertySymbols(indirect)) {
+      delete indirect[key];
+    }
+  } catch {
+    // Ignore errors.
   }
 
   Object.setPrototypeOf(indirect, target);

package/src/common/CommandModulesTransform.js

@@ -1,3 +1,4 @@
+import { trailingSlash } from "@weborigami/async-tree";
 import path from "node:path";
 
 /**
@@ -18,6 +19,7 @@ export default function CommandsModulesTransform(Base) {
       }
 
       // See if we have a JS module for the requested key.
+      key = trailingSlash.remove(key);
       if (key === undefined || key.endsWith?.(".js")) {
         return undefined;
       }

package/src/common/ExplorableSiteTransform.js

@@ -25,11 +25,6 @@ import { isTransformApplied, transformObject } from "../common/utilities.js";
 export default function ExplorableSiteTransform(Base) {
   return class ExplorableSite extends Base {
     async get(key) {
-      // The empty string key represents "index.html".
-      if (key === "") {
-        key = "index.html";
-      }
-
       // Ask the tree if it has the key.
       let value = await super.get(key);
 
@@ -49,11 +44,6 @@ export default function ExplorableSiteTransform(Base) {
         if (!isTransformApplied(ExplorableSiteTransform, value)) {
           value = transformObject(ExplorableSiteTransform, value);
         }
-
-        if (key.endsWith?.("/")) {
-          // Instead of return the tree directly, return an index for it.
-          value = await index.call(this, 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.
@@ -61,7 +51,8 @@ export default function ExplorableSiteTransform(Base) {
         const parent = this;
         value.unpack = async () => {
           const content = await original();
-          if (!Tree.isTraversable(content)) {
+          // See function notes at @debug
+          if (!Tree.isTraversable(content) || typeof content === "function") {
             return content;
           }
           /** @type {any} */
@@ -77,5 +68,11 @@ export default function ExplorableSiteTransform(Base) {
       }
       return value;
     }
+
+    // If this value is given to the server, the server will call this pack()
+    // method. We respond with the index page.
+    async pack() {
+      return this.get("index.html");
+    }
   };
 }

package/src/common/FilterTree.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, Tree, isPlainObject } from "@weborigami/async-tree";
+import { trailingSlash, Tree } from "@weborigami/async-tree";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
@@ -7,9 +7,8 @@ import { DeepObjectTree, Tree, isPlainObject } from "@weborigami/async-tree";
 export default class FilterTree {
   constructor(tree, filter) {
     this.tree = Tree.from(tree);
-    this.filter = isPlainObject(filter)
-      ? new DeepObjectTree(filter)
-      : Tree.from(filter);
+    this.filter = Tree.from(filter, { deep: true });
+    this.parent = null;
   }
 
   async get(key) {
@@ -41,7 +40,7 @@ export default class FilterTree {
       // must be a tree too.
       const match =
         (!isFilterValueTree && filterValue) ||
-        (isFilterValueTree && (await Tree.isKeyForSubtree(this.tree, key)));
+        (isFilterValueTree && trailingSlash.has(key));
       if (match) {
         keys.add(key);
       }
@@ -50,12 +49,12 @@ export default class FilterTree {
     // Also include any keys in the filter that are found in the tree. This
     // lets the filter "pull" values from a tree that, e.g., is defined by a
     // function without an explicit domain.
-    for (const key of await this.filter.keys()) {
-      const value = await this.tree.get(key);
-      if (value !== undefined) {
-        keys.add(key);
-      }
-    }
+    // for (const key of await this.filter.keys()) {
+    //   const value = await this.tree.get(key);
+    //   if (value !== undefined) {
+    //     keys.add(key);
+    //   }
+    // }
 
     return keys;
   }

package/src/common/GlobTree.js

@@ -1,10 +1,4 @@
-import {
-  DeepObjectTree,
-  ObjectTree,
-  Tree,
-  isPlainObject,
-  merge,
-} from "@weborigami/async-tree";
+import { ObjectTree, Tree, merge, trailingSlash } from "@weborigami/async-tree";
 
 const globstar = "**";
 
@@ -14,15 +8,17 @@ const globstar = "**";
  */
 export default class GlobTree {
   constructor(globs) {
-    this.globs = isPlainObject(globs)
-      ? new DeepObjectTree(globs)
-      : Tree.from(globs);
+    this.globs = Tree.from(globs, { deep: true });
   }
 
   async get(key) {
     if (typeof key !== "string") {
       return undefined;
     }
+
+    // Remove trailing slash if it exists
+    key = trailingSlash.remove(key);
+
     let value = await matchGlobs(this.globs, key);
     if (Tree.isAsyncTree(value)) {
       value = Reflect.construct(this.constructor, [value]);
@@ -35,8 +31,8 @@ export default class GlobTree {
   }
 }
 
+// Convert the glob to a regular expression
 function matchGlob(glob, text) {
-  // Convert the glob to a regular expression
   const regexText = glob
     // Escape special regex characters
     .replace(/[+?^${}()|\[\]\\]/g, "\\$&")
@@ -49,10 +45,15 @@ function matchGlob(glob, text) {
 
 async function matchGlobs(globs, text) {
   let value;
-  for (const glob of await globs.keys()) {
+  for (let glob of await globs.keys()) {
     if (typeof glob !== "string") {
       continue;
-    } else if (glob !== globstar && matchGlob(glob, text)) {
+    }
+
+    // Remove trailing slash if it exists
+    glob = trailingSlash.remove(glob);
+
+    if (glob !== globstar && matchGlob(glob, text)) {
       value = await globs.get(glob);
       if (value !== undefined) {
         break;

package/src/misc/treeDot.js

@@ -3,6 +3,7 @@ import {
   isPlainObject,
   isStringLike,
   toString,
+  trailingSlash,
 } from "@weborigami/async-tree";
 import * as serialize from "../common/serialize.js";
 import { keySymbol } from "../common/utilities.js";
@@ -49,7 +50,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
   // Draw edges and collect labels for the nodes they lead to.
   let nodes = new Map();
   for (const key of await tree.keys()) {
-    const destPath = nodePath ? `${nodePath}/${key}` : key;
+    const destPath = nodePath ? `${trailingSlash.add(nodePath)}${key}` : key;
     const arc = `  "${nodePath}" -> "${destPath}" [label="${key}"];`;
     result.push(arc);
 
@@ -163,7 +164,7 @@ async function statements(tree, nodePath, nodeLabel, options) {
     const label = `label="${icon}${text}"`;
     const color = node.isError ? `; color="red"` : "";
     const fill = node.isError ? `; fillcolor="#FFF4F4"` : "";
-    const destPath = nodePath ? `${nodePath}/${key}` : key;
+    const destPath = nodePath ? `${trailingSlash.add(nodePath)}${key}` : key;
     const url = createLinks ? `; URL="${destPath}"` : "";
     result.push(`  "${destPath}" [${label}${color}${fill}${url}];`);
   }

package/src/server/constructResponse.js

@@ -32,16 +32,6 @@ export default async function constructResponse(request, resource) {
   // Determine media type, what data we'll send, and encoding.
   const url = new URL(request.url ?? "", `https://${request.headers.host}`);
 
-  let mediaType;
-  if (resource.mediaType) {
-    // Resource indicates its own media type.
-    mediaType = resource.mediaType;
-  } else {
-    // Infer expected media type from file extension on request URL.
-    const extension = extname(url.pathname).toLowerCase();
-    mediaType = extension ? mediaTypeForExtension[extension] : undefined;
-  }
-
   if (!url.pathname.endsWith("/") && Tree.isTreelike(resource)) {
     // Treelike resource: redirect to its index page.
     const Location = `${url.pathname}/`;
@@ -57,6 +47,16 @@ export default async function constructResponse(request, resource) {
     resource = await resource.pack();
   }
 
+  let mediaType;
+  if (resource.mediaType) {
+    // Resource indicates its own media type.
+    mediaType = resource.mediaType;
+  } else {
+    // Infer expected media type from file extension on request URL.
+    const extension = extname(url.pathname).toLowerCase();
+    mediaType = extension ? mediaTypeForExtension[extension] : undefined;
+  }
+
   if (
     (mediaType === "application/json" || mediaType === "text/yaml") &&
     !isStringLike(resource)

package/src/server/parsePostData.js

@@ -0,0 +1,35 @@
+import { toString } from "@weborigami/async-tree";
+
+export default async function parsePostData(request) {
+  const data = await getPostData(request);
+  const type = request.headers["content-type"];
+  switch (type) {
+    case "application/json":
+      return JSON.parse(data);
+
+    case "application/x-www-form-urlencoded":
+      const params = new URLSearchParams(data);
+      return Object.fromEntries(params);
+
+    case "text/plain":
+      return toString(data);
+
+    default:
+      return data;
+  }
+}
+
+function getPostData(request) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    request.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    request.on("end", () => {
+      resolve(body);
+    });
+    request.on("error", (error) => {
+      reject(error);
+    });
+  });
+}

package/src/server/server.js

@@ -2,6 +2,7 @@ import { ObjectTree, Tree, keysFromPath } from "@weborigami/async-tree";
 import { formatError } from "@weborigami/language";
 import { ServerResponse } from "node:http";
 import constructResponse from "./constructResponse.js";
+import parsePostData from "./parsePostData.js";
 
 /**
  * Copy a constructed response to a ServerResponse. Return true if the response
@@ -81,13 +82,16 @@ export async function handleRequest(request, response, tree) {
       ? extendTreeScopeWithParams(tree, url)
       : tree;
 
+  const data = request.method === "POST" ? await parsePostData(request) : null;
+
   // Ask the tree for the resource with those keys.
   let resource;
   try {
     resource = await Tree.traverse(extendedTree, ...keys);
     // If resource is a function, invoke to get the object we want to return.
+    // For a POST request, pass the data to the function.
     if (typeof resource === "function") {
-      resource = await resource();
+      resource = data ? await resource(data) : await resource();
     }
   } catch (/** @type {any} */ error) {
     respondWithError(response, error);
@@ -111,8 +115,16 @@ function keysFromUrl(url) {
   const parts = url.pathname.split(/\/!/);
 
   // Split everything before the first command by slashes and decode those.
-  const path = parts.shift();
+  let path = parts.shift();
+  if (parts.length > 0) {
+    // HACK: Add back trailing slash that was removed by split
+    path += "/";
+  }
   const pathKeys = keysFromPath(path).map((key) => decodeURIComponent(key));
+  if (parts.length > 0 && pathKeys.at(-1) === "") {
+    // HACK part 2: Remove empty string that was added for trailing slash
+    pathKeys.pop();
+  }
 
   // If there are no commands, and the path ends with a trailing slash, the
   // final key will be an empty string. Change that to "index.html".