@weborigami/origami 0.0.59 → 0.0.61

package/src/builtins/@project.js

@@ -1,6 +1,7 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
-import { OrigamiFiles, Scope } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import { merge } from "@weborigami/async-tree";
+import { OrigamiFiles } from "@weborigami/language";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 import builtins from "./@builtins.js";
 import fileTypeOrigami from "./ori_handler.js";
 
@@ -22,43 +23,48 @@ const configFileName = "config.ori";
  * @param {any} [key]
  */
 export default async function project(key) {
-  assertScopeIsDefined(this, "project");
+  assertTreeIsDefined(this, "project");
 
   const dirname = process.cwd();
   const currentTree = new OrigamiFiles(dirname);
+  currentTree.parent = builtins;
 
   // Search up the tree for the configuration file or package.json to determine
   // the project root.
-  let rootTree =
+  const configContainer =
     (await findAncestorFile(currentTree, configFileName)) ??
     (await findAncestorFile(currentTree, "package.json"));
 
-  let config = null;
-  if (rootTree) {
-    // Load the configuration.
-    const configParent = Scope.treeWithScope(rootTree, builtins);
-    const buffer = await configParent.get(configFileName);
-    if (buffer) {
-      // Project has configuration file
-      config = await fileTypeOrigami.unpack(buffer, {
+  let projectRoot;
+  if (!configContainer) {
+    // No configuration file or package.json found; use the current directory.
+    projectRoot = currentTree;
+  } else {
+    // Load the configuration file if one exists.
+    const buffer = await configContainer.get(configFileName);
+    if (!buffer) {
+      // Project root defined by package.json
+      projectRoot = configContainer;
+    } else {
+      // Load Origami configuration file
+      const configTree = await fileTypeOrigami.unpack(buffer, {
         key: configFileName,
-        parent: configParent,
+        parent: configContainer,
       });
-      if (!config) {
-        const configPath = /** @type {any} */ (configParent).path;
+      if (!configTree) {
+        const configPath = /** @type {any} */ (configContainer).path;
         throw new Error(
           `Couldn't load the Origami configuration in ${configPath}/${configFileName}`
         );
       }
+      projectRoot = merge(configTree, configContainer);
+      // HACK so cli.js can get a path
+      /** @type {any} */ (projectRoot).path = configContainer.path;
+      projectRoot.parent = builtins;
     }
-  } else {
-    rootTree = currentTree;
   }
 
-  // Add the configuration as the context for the project root.
-  const scope = new Scope(config, builtins);
-  const result = Scope.treeWithScope(rootTree, scope);
-  return key === undefined ? result : result.get(key);
+  return key === undefined ? projectRoot : projectRoot.get(key);
 }
 
 // Return the first ancestor of the given tree that contains a file with the
@@ -68,7 +74,10 @@ async function findAncestorFile(start, fileName) {
   while (current) {
     const value = await current.get(fileName);
     if (value) {
-      // Found the desired file; its container is the project root.
+      // Found the desired file; its container is the project root. Set the
+      // parent to the builtins; in the context of this project, there's nothing
+      // higher up.
+      current.parent = builtins;
       return current;
     }
     // Not found; try the parent.

package/src/builtins/@reverse.js

@@ -1,5 +1,4 @@
 import { reverse } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
 /**
@@ -13,8 +12,7 @@ import getTreeArgument from "../misc/getTreeArgument.js";
  */
 export default async function reverseBuiltin(treelike) {
   const tree = await getTreeArgument(this, arguments, treelike, "@reverse");
-  let reversed = reverse(tree);
-  reversed = Scope.treeWithScope(reversed, this);
+  const reversed = reverse(tree);
   return reversed;
 }
 

package/src/builtins/@rss.js

@@ -1,55 +1,109 @@
 import { Tree } from "@weborigami/async-tree";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
+
+const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const months = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  * @this {AsyncTree|null}
  * @param {Treelike} jsonFeedTree
+ * @param {any} options
  */
-export default async function rss(jsonFeedTree) {
-  assertScopeIsDefined(this, "rss");
+export default async function rss(jsonFeedTree, options = {}) {
+  assertTreeIsDefined(this, "rss");
   const jsonFeed = await Tree.plain(jsonFeedTree);
-  const { description, home_page_url, items, feed_url, title } = jsonFeed;
+  const { description, home_page_url, items, title } = jsonFeed;
 
-  // Presume that the RSS feed lives in same location as feed_url.
-  const parts = feed_url.split("/");
-  parts.pop();
-  parts.push("rss.xml");
-  const rssUrl = parts.join("/");
+  let { feed_url, language } = options;
+  if (!feed_url && jsonFeed.feed_url) {
+    // Presume that the RSS feed lives in same location as feed_url
+    // but with a .xml extension.
+    feed_url = jsonFeed.feed_url;
+    if (feed_url.endsWith(".json")) {
+      feed_url = feed_url.replace(".json", ".xml");
+    }
+  }
 
   const itemsRss = items?.map((story) => itemRss(story)).join("") ?? [];
 
+  const titleElement = title ? `    <title>![CDATA[${title}]]</title>\n` : "";
+  const descriptionElement = description
+    ? `    <description>${description}</description>\n`
+    : "";
+  const linkElement = home_page_url
+    ? `    <link>${home_page_url}</link>\n`
+    : "";
+  const languageElement = language
+    ? `    <language>${language}</language>\n`
+    : "";
+  const feedLinkElement = `    <atom:link href="${feed_url}" rel="self" type="application/rss+xml"/>\n`;
+  // const feedLinkElement = `    <link rel="self" type="application/atom+xml" href="${feed_url}"/>\n`;
+
   return `<?xml version="1.0" ?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
   <channel>
-    <atom:link href="${rssUrl}" rel="self" type="application/rss+xml"/>
-    <title><![CDATA[${title}]]></title>
-    <link>${home_page_url}</link>
-    <description>${description}</description>
-${itemsRss}</channel>
+${titleElement}${descriptionElement}${linkElement}${languageElement}${feedLinkElement}${itemsRss}  </channel>
 </rss>`;
 }
 
 function itemRss(jsonFeedItem) {
-  const { content_html, date_published, id, title, url } = jsonFeedItem;
-  // RSS wants dates in RFC-822, essentially the same as ISO 8601.
+  const { content_html, id, summary, title, url } = jsonFeedItem;
+  let { date_published } = jsonFeedItem;
+  if (typeof date_published === "string") {
+    // Parse as ISO 8601 date.
+    date_published = new Date(date_published);
+  }
   const date =
     date_published instanceof Date
-      ? date_published.toUTCString()
+      ? toRFC822Date(date_published)
       : date_published;
+
   const dateElement = date ? `      <pubDate>${date}</pubDate>\n` : "";
-  const guidElement = id ? `      <guid>${id}</guid>\n` : "";
+  const isPermaLink =
+    id !== undefined && !URL.canParse(id) ? ` isPermaLink="false"` : "";
+  const guidElement = id ? `      <guid${isPermaLink}>${id}</guid>\n` : "";
+  const descriptionElement = summary
+    ? `      <description><![CDATA[${summary}]]></description>\n`
+    : "";
   const contentElement = content_html
-    ? `      <description><![CDATA[${content_html}]]></description>\n`
+    ? `      <content:encoded><![CDATA[${content_html}]]></content:encoded>\n`
+    : "";
+  const titleElement = title
+    ? `      <title><![CDATA[${title}]]></title>\n`
     : "";
-  const titleElement = `<![CDATA[${title}]]>`;
+  const linkElement = url ? `      <link>${url}</link>\n` : "";
+
   return `    <item>
-${dateElement}      <title>${titleElement}</title>
-      <link>${url}</link>
-${guidElement}${contentElement}    </item>
+${dateElement}${titleElement}${linkElement}${guidElement}${descriptionElement}${contentElement}    </item>
 `;
 }
 
+// RSS wants dates in RFC-822.
+function toRFC822Date(date) {
+  const day = days[date.getUTCDay()];
+  const dayOfMonth = date.getUTCDate().toString().padStart(2, "0");
+  const month = months[date.getUTCMonth()];
+  const year = date.getUTCFullYear();
+  const hours = date.getUTCHours().toString().padStart(2, "0");
+  const minutes = date.getUTCMinutes().toString().padStart(2, "0");
+  const seconds = date.getUTCSeconds().toString().padStart(2, "0");
+  return `${day}, ${dayOfMonth} ${month} ${year} ${hours}:${minutes}:${seconds} GMT`;
+}
+
 rss.usage = `@rss <feed>\tTransforms a JSON Feed tree to RSS XML`;
 rss.documentation = "https://weborigami.org/language/@rss.html";

package/src/builtins/@serve.js

@@ -4,7 +4,7 @@ import { createServer } from "node:net";
 import process from "node:process";
 import ExplorableSiteTransform from "../common/ExplorableSiteTransform.js";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 import { requestListener } from "../server/server.js";
 import debug from "./@debug.js";
 import watch from "./@watch.js";
@@ -22,7 +22,7 @@ const defaultPort = 5000;
  * @this {AsyncTree|null}
  */
 export default async function serve(treelike, port) {
-  assertScopeIsDefined(this, "serve");
+  assertTreeIsDefined(this, "serve");
   let tree;
   if (treelike) {
     tree = Tree.from(treelike);

package/src/builtins/@sitemap.js

@@ -1,3 +1,4 @@
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 import builtins from "./@builtins.js";
 import paths from "./@paths.js";
@@ -22,6 +23,7 @@ const templateText = `(urls) => \`<?xml version="1.0" encoding="UTF-8"?>
  * @param {string} [baseHref ]
  */
 export default async function sitemap(treelike, baseHref = "") {
+  assertTreeIsDefined(this, "sitemap");
   const tree = await getTreeArgument(this, arguments, treelike, "@sitemap");
 
   // We're only interested in keys that end in .html or with no extension.
@@ -49,7 +51,8 @@ export default async function sitemap(treelike, baseHref = "") {
     .map((path) => (path.endsWith("index.html") ? path.slice(0, -10) : path));
 
   const templateFn = await fileTypeOrigami.unpack(templateText);
-  const templateResult = await templateFn.call(builtins, htmlPaths);
+  const target = this ?? builtins;
+  const templateResult = await templateFn.call(target, htmlPaths);
   return String(templateResult);
 }
 

package/src/builtins/@sortFn.js

@@ -1,7 +1,6 @@
 import { sortFn } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import { toFunction } from "../common/utilities.js";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Return a transform function that sorts a tree's keys using a comparison
@@ -23,8 +22,8 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {ValueKeyFn|SortOptions} [options]
  */
 export default function sortFnBuiltin(options) {
-  assertScopeIsDefined(this);
-  const scope = this;
+  assertTreeIsDefined(this, "sortFn");
+  const parent = this;
 
   if (typeof options === "function") {
     // Take the function as the `sortKey` option
@@ -37,7 +36,7 @@ export default function sortFnBuiltin(options) {
     const originalSortKey = toFunction(options?.sortKey);
     extendedSortKeyFn = async (key, tree) => {
       const value = await tree.get(key);
-      const sortKey = await originalSortKey.call(scope, value, key);
+      const sortKey = await originalSortKey.call(parent, value, key);
       return sortKey;
     };
   }
@@ -49,8 +48,8 @@ export default function sortFnBuiltin(options) {
 
   return (treelike) => {
     const sorted = fn(treelike);
-    const scoped = Scope.treeWithScope(sorted, scope);
-    return scoped;
+    sorted.parent = parent;
+    return sorted;
   };
 }
 

package/src/builtins/@string.js

@@ -1,5 +1,5 @@
 import { toString } from "../common/utilities.js";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Convert an object to a string.
@@ -9,6 +9,6 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {any} object
  */
 export default function stringBuiltin(object) {
-  assertScopeIsDefined(this, "string");
+  assertTreeIsDefined(this, "string");
   return toString(object);
 }

package/src/builtins/@takeFn.js

@@ -1,6 +1,5 @@
 import { takeFn } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Limit the number of keys to the indicated count.
@@ -11,11 +10,11 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {number} count
  */
 export default function takeFnBuiltin(count) {
-  assertScopeIsDefined(this, "takeFn");
-  const scope = this;
+  assertTreeIsDefined(this, "takeFn");
+  const parent = this;
   return (treelike) => {
     const taken = takeFn(count)(treelike);
-    const scoped = Scope.treeWithScope(taken, scope);
-    return scoped;
+    taken.parent = parent;
+    return taken;
   };
 }

package/src/builtins/@treeHttp.js

@@ -1,5 +1,5 @@
 import { ops } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
@@ -11,7 +11,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param  {...string|Symbol} keys
  */
 export default function treeHttp(host, ...keys) {
-  assertScopeIsDefined(this, "treeHttp");
+  assertTreeIsDefined(this, "treeHttp");
   return ops.treeHttp.call(this, host, ...keys);
 }
 

package/src/builtins/@treeHttps.js

@@ -1,5 +1,5 @@
 import { ops } from "@weborigami/language";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * @typedef  {import("@weborigami/types").AsyncTree} AsyncTree
@@ -11,7 +11,7 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param  {...string|Symbol} keys
  */
 export default function treeHttps(host, ...keys) {
-  assertScopeIsDefined(this, "treeHttps");
+  assertTreeIsDefined(this, "treeHttps");
   return ops.treeHttps.call(this, host, ...keys);
 }
 

package/src/builtins/@unpack.js

@@ -1,4 +1,4 @@
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Unpack a packed format like a Uint8Array or ArrayBuffer to a usable form like
@@ -9,6 +9,6 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {any} obj
  */
 export default function unpack(obj) {
-  assertScopeIsDefined(this, "unpack");
+  assertTreeIsDefined(this, "unpack");
   return obj?.unpack?.();
 }

package/src/builtins/@watch.js

@@ -1,5 +1,4 @@
 import { Tree } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import ConstantTree from "../common/ConstantTree.js";
 import getTreeArgument from "../misc/getTreeArgument.js";
 
@@ -21,16 +20,12 @@ export default async function watch(treelike, fn) {
   // Watch the indicated tree.
   await /** @type {any} */ (container).watch?.();
 
-  // // Watch trees in scope.
-  // const scope = /** @type {any} */ (container).scope;
-  // await scope?.watch?.();
-
   if (fn === undefined) {
     return container;
   }
 
   // The caller supplied a function to reevaluate whenever the tree changes.
-  let tree = await evaluateTree(container.scope, fn);
+  let tree = await evaluateTree(container, fn);
 
   // 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
@@ -40,19 +35,19 @@ export default async function watch(treelike, fn) {
 
   // Reevaluate the function whenever the tree changes.
   container.addEventListener?.("change", async () => {
-    const tree = await evaluateTree(container.scope, fn);
+    const tree = await evaluateTree(container, fn);
     updateIndirectPointer(handle, tree);
   });
 
   return handle;
 }
 
-async function evaluateTree(scope, fn) {
+async function evaluateTree(container, fn) {
   let tree;
   let message;
   let result;
   try {
-    result = await fn.call(scope);
+    result = await fn.call(container);
   } catch (error) {
     message = messageForError(error);
   }
@@ -65,9 +60,7 @@ async function evaluateTree(scope, fn) {
   }
   console.warn(message);
   tree = new ConstantTree(message);
-  if (scope) {
-    tree = Scope.treeWithScope(tree, scope);
-  }
+  tree.parent = container;
   return tree;
 }
 

package/src/builtins/@yaml.js

@@ -1,7 +1,7 @@
 /** @typedef {import("@weborigami/types").AsyncTree} AsyncTree */
 import { isUnpackable, toPlainValue } from "@weborigami/async-tree";
 import YAML from "yaml";
-import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
+import assertTreeIsDefined from "../misc/assertTreeIsDefined.js";
 
 /**
  * Render the object as text in YAML format.
@@ -10,14 +10,14 @@ import assertScopeIsDefined from "../misc/assertScopeIsDefined.js";
  * @param {any} [obj]
  */
 export default async function toYaml(obj) {
-  assertScopeIsDefined(this, "yaml");
+  assertTreeIsDefined(this, "yaml");
   // 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."
     );
   }
-  obj = obj ?? (await this?.get("@current"));
+  obj = obj ?? this;
   if (obj === undefined) {
     return undefined;
   }

package/src/builtins/ori_handler.js

@@ -1,5 +1,5 @@
 import { symbols } from "@weborigami/async-tree";
-import { Scope, compile } from "@weborigami/language";
+import { compile } from "@weborigami/language";
 import processUnpackedContent from "../common/processUnpackedContent.js";
 import * as utilities from "../common/utilities.js";
 import builtins from "./@builtins.js";
@@ -40,8 +40,8 @@ export default {
     // Compile the source code as an Origami expression and evaluate it.
     const compiler = options.compiler ?? compile.expression;
     const fn = compiler(source);
-    const parentScope = parent ? Scope.getScope(parent) : builtins;
-    let content = await fn.call(parentScope);
+    const target = parent ?? builtins;
+    let content = await fn.call(target);
 
     return processUnpackedContent(content, parent, attachedData);
   },

package/src/builtins/~.js

@@ -1,9 +1,9 @@
-import { OrigamiFiles, Scope } from "@weborigami/language";
+import { OrigamiFiles } from "@weborigami/language";
 import os from "node:os";
 import builtins from "./@builtins.js";
 
 /** @type {import("@weborigami/types").AsyncTree} */
-let tree = new OrigamiFiles(os.homedir());
-tree = Scope.treeWithScope(tree, builtins);
+const tree = new OrigamiFiles(os.homedir());
+tree.parent = builtins;
 
 export default tree;

package/src/cli/cli.js

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 
-import { ObjectTree, Tree } from "@weborigami/async-tree";
-import { Scope, formatError } from "@weborigami/language";
+import { Tree } from "@weborigami/async-tree";
+import { formatError } from "@weborigami/language";
 import path from "node:path";
 import process, { stdout } from "node:process";
 import ori from "../builtins/@ori.js";
 import project from "../builtins/@project.js";
-import { keySymbol } from "../common/utilities.js";
 import showUsage from "./showUsage.js";
 
 const TypedArray = Object.getPrototypeOf(Uint8Array);
@@ -17,32 +16,20 @@ async function main(...args) {
   // Find the project root.
   const projectTree = await project.call(null);
 
-  // HACK: get the configuration via the project.
-  const config = new Scope(...projectTree.scope.trees.slice(1));
-
   // If no arguments were passed, show usage.
   if (!expression) {
+    // HACK: the config is the parent of the project tree.
+    const config = projectTree.parent;
     await showUsage(config);
     return;
   }
 
-  // Splice ambients tree into project tree scope.
-  const ambients = new ObjectTree({});
-  ambients[keySymbol] = "Origami CLI";
-  let tree = Scope.treeWithScope(projectTree, new Scope(ambients, config));
-
   // Traverse from the project root to the current directory.
   const currentDirectory = process.cwd();
   const relative = path.relative(projectTree.path, currentDirectory);
-  if (relative !== "") {
-    tree = await Tree.traversePath(tree, relative);
-  }
-
-  // Add ambient property for the current tree.
-  await ambients.set("@current", tree);
+  const tree = await Tree.traversePath(projectTree, relative);
 
-  const scope = Scope.getScope(tree);
-  const result = await ori.call(scope, expression);
+  const result = await ori.call(tree, expression);
   if (result !== undefined) {
     const output =
       result instanceof ArrayBuffer

package/src/common/ConstantTree.js

@@ -5,6 +5,7 @@
 export default class ConstantTree {
   constructor(value) {
     this.value = value;
+    this.parent = null;
   }
 
   async get(key) {

package/src/common/ExplorableSiteTransform.js

@@ -1,5 +1,4 @@
 import { Tree, keysJson } from "@weborigami/async-tree";
-import { Scope } from "@weborigami/language";
 import index from "../builtins/@index.js";
 import { isTransformApplied, transformObject } from "../common/utilities.js";
 
@@ -33,16 +32,14 @@ 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.
-        if (scope) {
-          if (key === "index.html") {
-            value = await index.call(scope, this);
-          } else if (key === ".keys.json") {
-            value = await keysJson.stringify(this);
-          }
+        if (key === "index.html") {
+          // This tree is both the function call target and the parameter.
+          value = await index.call(this, this);
+        } else if (key === ".keys.json") {
+          value = await keysJson.stringify(this);
         }
       }
 
@@ -55,12 +52,13 @@ export default function ExplorableSiteTransform(Base) {
 
         if (key.endsWith?.("/")) {
           // Instead of return the tree directly, return an index for it.
-          value = await index.call(scope, value);
+          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.
         const original = value.unpack.bind(value);
+        const parent = this;
         value.unpack = async () => {
           const content = await original();
           if (!Tree.isTraversable(content)) {
@@ -68,9 +66,8 @@ export default function ExplorableSiteTransform(Base) {
           }
           /** @type {any} */
           let tree = Tree.from(content);
-          if (!tree.parent && !tree.scope) {
-            const scope = Scope.getScope(this);
-            tree = Scope.treeWithScope(tree, scope);
+          if (!tree.parent) {
+            tree.parent = parent;
           }
           if (!isTransformApplied(ExplorableSiteTransform, tree)) {
             tree = transformObject(ExplorableSiteTransform, tree);

package/src/common/documentObject.js

@@ -1,4 +1,4 @@
-import { isPlainObject, isUnpackable } from "@weborigami/async-tree";
+import { isPlainObject, isUnpackable, toString } from "@weborigami/async-tree";
 // import txtHandler from "../builtins/txt_handler.js";
 
 /**
@@ -25,7 +25,7 @@ export default async function documentObject(input, data) {
     text = input["@text"];
     inputData = input;
   } else {
-    text = String(input);
+    text = toString(input);
     inputData = null;
   }
   // TODO: Either restore this code, or move responsibility for packing a