@unoverse-platform/studio 0.1.93 → 0.1.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {

package/vendor/base/src/lint/nodes/index.mjs

@@ -15,7 +15,7 @@
  *
  * FOUR TIERS (docs/architecture/DECLARATIVE_NODES.md §6). This is tiers 2 and 3.
  *   1  editor    $schema pointers + .vscode yaml.schemas, no tool
- *   2  structural   every part validated against nodes/_schema/*.json
+ *   2  structural   every part validated against the node schemas (packages/docs/schemas/nodes)
  *   3  semantic     the cross-file rules a schema cannot express
  *   4  dry run      `unoverse node test`, executes against testData, not here
  */
@@ -36,16 +36,17 @@ import { lintPackage } from "./package.mjs";
 /**
  * Where the node schemas are, for this run.
  *
- * The platform's own tree carries them at `nodes/_schema/`, and every node file points at
- * them with `$schema:` for editor squiggles. A DEVELOPER'S WORKSPACE DOES NOT: it holds only
- * their packages, and a linter that then warned "no schema found" on every file was
- * validating nothing while looking busy. So the schemas travel with the linter. In dist
- * they sit beside this file (copy-lint.mjs puts them there, and the CLI vendors that
- * folder); from source they are the monorepo's copy, five levels up.
+ * Their home is packages/docs/schemas/nodes, which the docs site serves at the URL every
+ * node file's `$schema:` names (so any editor validates online). The linter runs offline
+ * and a developer's workspace holds no copy, and a linter that warned "no schema found" on
+ * every file was validating nothing while looking busy. So the schemas travel with the
+ * linter: in dist they sit beside this file (copy-lint.mjs puts them there, and the CLI
+ * vendors that folder); from source they are the docs tree's copy. A `_schema` folder in
+ * the workspace itself still wins, for anyone pinning a version.
  */
 function schemaHome(home) {
   const here = dirname(fileURLToPath(import.meta.url));
-  for (const c of [join(home, "_schema"), join(here, "_schema"), resolve(here, "../../../../../apps/unoverse/nodes/_schema")])
+  for (const c of [join(home, "_schema"), join(here, "_schema"), resolve(here, "../../../../docs/schemas/nodes")])
     if (existsSync(c)) return c;
   return join(home, "_schema");
 }

package/vendor/base/src/lint/nodes/schema.mjs

@@ -1,5 +1,5 @@
 /**
- * Tier 2: structural validation against nodes/_schema/*.json.
+ * Tier 2: structural validation against the node schemas (packages/docs/schemas/nodes).
  *
  * A JSON Schema catches shape. Everything a schema CANNOT express (cross-file agreement,
  * ordering, reachability) is tier 3 and lives in the rule modules.
@@ -53,7 +53,7 @@ export function loadSchemas() {
 export function validateAgainst(schemaId, doc, file, label) {
   const schema = state.schemas[schemaId];
   if (!schema) {
-    report("warn", file, `no schema found for ${label}. Is nodes/_schema/ present?`);
+    report("warn", file, `no schema found for ${label}. The linter's bundled schemas are missing; rebuild base`);
     return;
   }
   const v = new Validator(schema, "7", false);

package/vendor/base/src/manifests/runtime/templating.ts

@@ -47,7 +47,9 @@ export async function primeTemplating(): Promise<void> {}
  * Deliberately only a dotted path: anything with a helper or a block is genuinely
  * text assembly and belongs in Handlebars.
  */
-const WHOLE_VALUE = /^\s*\{\{\s*([a-zA-Z_$][\w$]*(?:\.[\w$]+)*)\s*\}\}\s*$/;
+// A segment may carry `-` or `/`: an org component's box is `<org>/<name>N`, and its
+// paths are written as advertised (StringTemplateResolver, bracketSlashSegments).
+const WHOLE_VALUE = /^\s*\{\{\s*([a-zA-Z_$][\w$/-]*(?:\.[\w$/-]+)*)\s*\}\}\s*$/;
 
 function lookup(path: string, ctx: RunContext): unknown {
   return path.split(".").reduce<any>((a, k) => (a == null ? a : a[k]), ctx as any);

package/vendor/base/src/template/StringTemplateResolver.ts

@@ -48,10 +48,51 @@ Handlebars.registerHelper("contains", function (str, substring) {
   return str.toLowerCase().includes(substring.toLowerCase());
 });
 
+/**
+ * A NODE ID MAY CARRY A SLASH, and Handlebars reads `/` as a path separator.
+ *
+ * An org component's box is minted as `<org>/<name>N` (componentRef), and every path
+ * the platform advertises for it is written the way an author would write it:
+ * `{{signal.some-org/card2.output.state}}`. Handlebars parses that as
+ * `signal.some-org.card2…`, finds nothing, and renders "" — no error, no log, an
+ * empty string where a page's state should be. Observed live 2026-09-05: a component
+ * capture parsed "" as JSON and the name on every extracted row was blank.
+ *
+ * Handlebars' own answer is the segment literal, `[some-org/card2]`, so every
+ * segment that carries a slash is bracketed before compile. Only bare path segments
+ * qualify (letters, digits, `_ $ -` and `/`): a quoted string, a URL with its colon, or
+ * a segment already bracketed is left exactly as written.
+ */
+const SLASH_SEGMENT = /(?<=^|[\s.(|=])([\w$-]+(?:\/[\w$-]+)+)(?=[.\s)}|]|$)/g;
+export function bracketSlashSegments(template: string): string {
+  if (!template.includes("/")) return template;
+  return template.replace(/\{\{[^}]*\}\}/g, (mustache) => {
+    let out = "";
+    let quote: string | null = null;
+    let run = "";
+    const flush = () => {
+      out += run.replace(SLASH_SEGMENT, "[$1]");
+      run = "";
+    };
+    for (const ch of mustache) {
+      if (quote) {
+        out += ch;
+        if (ch === quote) quote = null;
+      } else if (ch === '"' || ch === "'") {
+        flush();
+        quote = ch;
+        out += ch;
+      } else run += ch;
+    }
+    flush();
+    return out;
+  });
+}
+
 // Create a memoized template compiler for performance
 const compileTemplate = memoize((template: string) => {
   // Disable HTML escaping to prevent issues like "I'll" becoming "I&#x27;ll"
-  return Handlebars.compile(template, { noEscape: true });
+  return Handlebars.compile(bracketSlashSegments(template), { noEscape: true });
 });
 
 export function resolveStringTemplate(template: string, context: TemplateContext, logger: any): any {