pandorga 1.2.1

data/scripts/test/test-studio-rewrite-sanitize.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * AC-PRF-05, AC-PRF-06, AC-PRF-07, AC-PRF-15 — patch sanitizer + block chunking.
+ * Spec: docs/features/studio-proof.md §8
+ */
+import assert from "node:assert/strict";
+import {
+  flattenBlockPatches,
+  locateUnique,
+  splitIntoBlocks,
+} from "../../functions/api/studio/_lib/blocks.js";
+import { sanitizePatches } from "../../functions/api/studio/_lib/sanitize.js";
+import {
+  buildGeminiRequest,
+  truncateGuidelines,
+} from "../../functions/api/studio/_lib/prompts.js";
+
+const text =
+  'Hello wrld.\n\n{% include figure.html src="/media/x.png" %}\n\n`code` and ```\nfence\n```\n';
+
+{
+  const { patches, stats } = sanitizePatches({
+    mode: "correct",
+    text,
+    patches: [
+      {
+        start: 6,
+        end: 10,
+        original: "wrld",
+        replacement: "world",
+        category: "spelling",
+        reason: "typo",
+      },
+      {
+        start: 6,
+        end: 10,
+        original: "NOPE",
+        replacement: "world",
+        category: "spelling",
+        reason: "bad",
+      },
+      {
+        start: text.indexOf("{%"),
+        end: text.indexOf("%}") + 2,
+        original: text.slice(text.indexOf("{%"), text.indexOf("%}") + 2),
+        replacement: "x",
+        category: "grammar",
+        reason: "include",
+      },
+      {
+        start: 0,
+        end: 5,
+        original: "Hello",
+        replacement: "Hiya!",
+        category: "clarity",
+        reason: "style",
+      },
+    ],
+  });
+  assert.equal(patches.length, 1);
+  assert.equal(patches[0].replacement, "world");
+  assert.equal(stats.kept, 1);
+  assert.ok(stats.dropped >= 1);
+}
+
+{
+  // Offset recovery: wrong start/end, exact original still locates.
+  const { patches } = sanitizePatches({
+    mode: "correct",
+    text: "alpha beta gamma",
+    patches: [
+      {
+        start: 99,
+        end: 103,
+        original: "beta",
+        replacement: "BETA",
+        category: "spelling",
+        reason: "case",
+      },
+    ],
+  });
+  assert.equal(patches.length, 1);
+  assert.equal(patches[0].start, 6);
+  assert.equal(patches[0].end, 10);
+}
+
+{
+  const { patches } = sanitizePatches({
+    mode: "refine",
+    text: "A clunky sentence here.",
+    patches: [
+      {
+        start: 0,
+        end: 23,
+        original: "A clunky sentence here.",
+        replacement: "A clearer sentence here.",
+        category: "clarity",
+        reason: "flow",
+      },
+    ],
+  });
+  assert.equal(patches.length, 1);
+  assert.equal(patches[0].category, "clarity");
+}
+
+{
+  // {% cite %} is protected like include.
+  const src = "Antes {% cite turino-2008 %} depois.";
+  const cite = "{% cite turino-2008 %}";
+  const at = src.indexOf(cite);
+  const { patches } = sanitizePatches({
+    mode: "refine",
+    text: src,
+    patches: [
+      {
+        start: at,
+        end: at + cite.length,
+        original: cite,
+        replacement: "REMOVED",
+        category: "clarity",
+        reason: "bad",
+      },
+    ],
+  });
+  assert.equal(patches.length, 0);
+}
+
+{
+  const body =
+    "First paragraph here.\n\nSecond paragraph here.\n\n## Heading\n\nThird paragraph with more words to grow.";
+  const blocks = splitIntoBlocks(body, { targetChars: 40, maxChars: 80 });
+  assert.ok(blocks.length >= 2);
+  assert.equal(blocks[0].start, 0);
+  assert.equal(body.slice(blocks[0].start, blocks[0].end), blocks[0].text);
+  const joined = blocks.map((b) => b.text).join("");
+  // Separators are kept on preceding blocks; concatenation should rebuild body.
+  assert.equal(joined, body);
+}
+
+{
+  const body = "Alpha one.\n\nBeta two.\n\nGamma three.";
+  const blocks = splitIntoBlocks(body, { targetChars: 10, maxChars: 20 });
+  const flat = flattenBlockPatches(blocks, [
+    {
+      block: 1,
+      original: "Beta two.",
+      replacement: "Beta too.",
+      category: "clarity",
+      reason: "tight",
+    },
+  ]);
+  assert.equal(flat.length, 1);
+  assert.equal(body.slice(flat[0].start, flat[0].end), "Beta two.");
+}
+
+{
+  const hit = locateUnique("aa bb aa", "aa", 5);
+  assert.equal(hit.start, 6);
+}
+
+{
+  const req = buildGeminiRequest({
+    mode: "correct",
+    language: "en",
+    path: "content/collections/articles/x.md",
+    text: "teh",
+  });
+  const sys = req.systemInstruction.parts[0].text;
+  assert.ok(sys.includes("mechanical corrector"));
+  assert.ok(!sys.includes("Writing guidelines (published pack)"));
+  assert.equal(
+    req.generationConfig.responseSchema.properties.patches.items.required.includes(
+      "start"
+    ),
+    true
+  );
+}
+
+{
+  const blocks = splitIntoBlocks("Short prose for refine.\n\nAnother beat.");
+  const req = buildGeminiRequest({
+    mode: "refine",
+    language: "pt-BR",
+    path: "content/collections/posts/x.md",
+    text: "Short prose for refine.\n\nAnother beat.",
+    guidelinesBody: "You are not a co-author.\n",
+    blocks,
+  });
+  const sys = req.systemInstruction.parts[0].text;
+  const user = req.contents[0].parts[0].text;
+  assert.ok(sys.includes("tone consistency") || sys.includes("Preserve tone"));
+  assert.ok(sys.includes("not a co-author"));
+  assert.ok(sys.includes("invoked Refine"));
+  assert.ok(user.includes("blocks:"));
+  assert.ok(user.includes("[0]"));
+  assert.ok(
+    req.generationConfig.responseSchema.properties.patches.items.required.includes(
+      "block"
+    )
+  );
+}
+
+{
+  const long = "a".repeat(100);
+  const truncated = truncateGuidelines(long, 50);
+  assert.ok(truncated.length < long.length);
+  assert.ok(truncated.includes("truncated"));
+}
+
+console.log("All Studio rewrite sanitize checks passed.");

data/scripts/test/test-studio-schema-composition.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Refs: PLT-AC-3 — Studio schema includes registry collections and drops them
+# when the page is removed.
+require "pathname"
+require "yaml"
+require "fileutils"
+require "tmpdir"
+require "open3"
+
+ROOT = Pathname.new(__dir__).join("../..").expand_path
+$LOAD_PATH.unshift(ROOT.join("lib").to_s)
+require "pandorga"
+require "pandorga/commands/studio_schema"
+
+EXAMPLE = ROOT.join("examples/full")
+TEMPLATES = ROOT.join("templates")
+EXE = ROOT.join("exe/pandorga")
+
+def fail!(message)
+  warn "FAIL test-studio-schema-composition: #{message}"
+  exit 1
+end
+
+def registered_collections(config)
+  names = []
+  Array(config.dig("pandorga", "pages")).each do |page|
+    next unless page.is_a?(Hash)
+
+    single = page["collection"].to_s
+    names << single unless single.empty?
+
+    cols = page["collections"]
+    next unless cols.is_a?(Hash)
+
+    cols.each_value do |name|
+      n = name.to_s
+      next if n.empty? || n == "data" || n == "profile"
+
+      names << n
+    end
+  end
+  names.uniq
+end
+
+def collection_names_from_schema(schema)
+  names = []
+  Array(schema["content"]).each do |group|
+    next unless group.is_a?(Hash)
+
+    Array(group["items"]).each do |item|
+      next unless item.is_a?(Hash)
+      next unless item["type"].to_s == "collection"
+
+      names << item["name"].to_s
+    end
+  end
+  if schema["collections"].is_a?(Hash)
+    names |= schema["collections"].keys.map(&:to_s)
+  end
+  names.uniq
+end
+
+config = YAML.safe_load(EXAMPLE.join("_config.yml").read, aliases: true)
+expected = registered_collections(config)
+fail!("examples/full has no registered collections") if expected.empty?
+
+composer = Pandorga::Commands::StudioSchema.new
+schema = composer.compose(config, TEMPLATES)
+present = collection_names_from_schema(schema)
+
+missing = expected - present
+fail!("schema missing collections: #{missing.inspect} (have #{present.inspect})") unless missing.empty?
+
+unless schema["media"].is_a?(Hash)
+  fail!("composed schema should include a media block when templates need it")
+end
+
+unless schema["content"].is_a?(Array) && !schema["content"].empty?
+  fail!("composed schema should include content groups")
+end
+
+# Taxonomy from examples/full should land on the articles tags field.
+articles_entry = schema.dig("collections", "articles")
+fail!("articles collection missing from index") unless articles_entry.is_a?(Hash)
+tags_field = Array(articles_entry["fields"]).find { |f| f.is_a?(Hash) && f["name"] == "tags" }
+tag_values = tags_field&.dig("options", "values")
+unless tag_values == ["Writing"]
+  fail!("articles tags should come from pandorga.taxonomies (got #{tag_values.inspect})")
+end
+
+# Remove the articles page; articles must leave the schema.
+reduced = Marshal.load(Marshal.dump(config))
+reduced["pandorga"]["pages"].reject! { |p| p.is_a?(Hash) && p["key"].to_s == "articles" }
+reduced_schema = composer.compose(reduced, TEMPLATES)
+reduced_names = collection_names_from_schema(reduced_schema)
+if reduced_names.include?("articles")
+  fail!("articles still present after removing the page from the registry")
+end
+still_expected = registered_collections(reduced)
+still_missing = still_expected - reduced_names
+unless still_missing.empty?
+  fail!("after removal, still missing: #{still_missing.inspect}")
+end
+
+# CLI writes schema under a temp site root (optional end-to-end check).
+Dir.mktmpdir("pandorga-studio-schema-") do |dir|
+  site = Pathname.new(dir)
+  FileUtils.cp(EXAMPLE.join("_config.yml"), site.join("_config.yml"))
+  env = { "RUBYOPT" => "-I#{ROOT.join('lib')}" }
+  stdout, stderr, status = Open3.capture3(
+    env, "ruby", EXE.to_s, "studio-schema", site.to_s
+  )
+  fail!("CLI failed: #{stdout}\n#{stderr}") unless status.success?
+
+  written = site.join("studio/schema.yml")
+  fail!("CLI did not write #{written}") unless written.file?
+
+  from_disk = YAML.safe_load(written.read, aliases: true)
+  disk_names = collection_names_from_schema(from_disk)
+  disk_missing = expected - disk_names
+  fail!("CLI schema missing: #{disk_missing.inspect}") unless disk_missing.empty?
+end
+
+puts "PASS test-studio-schema-composition (#{expected.length} collections; removal + CLI ok)"

data/scripts/test/test-studio-slug-config.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# AC-STU: Studio schema replaces .pages.yml as the live CMS model.
+# Spec: docs/features/studio.md
+
+require "date"
+require "pathname"
+require "yaml"
+
+REPO_ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+CONFIG_PATH = REPO_ROOT.join("studio/schema.yml")
+
+def check!(condition, message = "condition was false")
+  raise "Assertion failed: #{message}" unless condition
+end
+
+def each_content_entry(nodes, &block)
+  Array(nodes).each do |entry|
+    next unless entry.is_a?(Hash)
+
+    type = entry["type"].to_s
+    if type == "group"
+      each_content_entry(entry["items"], &block)
+    else
+      yield entry
+    end
+  end
+end
+
+def find_collection(config, name)
+  found = nil
+  each_content_entry(config["content"]) do |entry|
+    found = entry if entry["type"].to_s == "collection" && entry["name"].to_s == name
+  end
+  found
+end
+
+def field_names(collection)
+  (collection["fields"] || []).map { |field| field["name"].to_s }
+end
+
+puts "Testing Studio schema (studio/schema.yml)..."
+
+check!(CONFIG_PATH.file?, "missing studio/schema.yml")
+
+config = YAML.safe_load(CONFIG_PATH.read, permitted_classes: [Date, Time], aliases: true) || {}
+check!(config["media"].is_a?(Hash) || config["media"].is_a?(String) || config["media"].is_a?(Array),
+       "studio/schema.yml must define media")
+
+media = config["media"]
+media_input = nil
+if media.is_a?(Hash)
+  media_input = media["input"].to_s
+  check!(media_input.include?("content/media"),
+         "schema media.input must point under content/media")
+  check!(media["output"].to_s.start_with?("/media"),
+         "schema media.output must be a /media public path")
+elsif media.is_a?(Array)
+  images = media.find { |entry| entry.is_a?(Hash) && entry["name"].to_s == "images" } || media.first
+  media_input = images.is_a?(Hash) ? images["input"].to_s : nil
+end
+
+if media_input && !media_input.empty?
+  each_content_entry(config["content"]) do |entry|
+    (entry["fields"] || []).each do |field|
+      next unless field.is_a?(Hash) && field["type"].to_s == "image"
+
+      path = field.dig("options", "path").to_s
+      next if path.empty?
+
+      check!(path == media_input || path.start_with?("#{media_input}/"),
+             "#{entry['name']}.#{field['name']} options.path must start with media.input " \
+             "(#{media_input.inspect}); got #{path.inspect}")
+    end
+  end
+end
+
+posts = find_collection(config, "posts")
+articles = find_collection(config, "articles")
+check!(!posts.nil?, "missing posts collection in studio/schema.yml")
+check!(!articles.nil?, "missing articles collection in studio/schema.yml")
+
+check!(posts["format"].to_s == "yaml-frontmatter",
+       "posts must use yaml-frontmatter")
+check!(articles["format"].to_s == "yaml-frontmatter",
+       "articles must use yaml-frontmatter")
+check!(posts.dig("operations", "delete") == false,
+       "posts operations.delete must be false")
+check!(articles.dig("operations", "delete") == false,
+       "articles operations.delete must be false")
+
+posts_fields = field_names(posts)
+articles_fields = field_names(articles)
+
+check!(!posts_fields.include?("description"),
+       "posts must not expose description (excerpts come from the body)")
+check!(!posts_fields.include?("last_updated"),
+       "posts must not expose last_updated (build derives it from Git)")
+check!(!articles_fields.include?("last_updated"),
+       "articles must not expose last_updated (build derives it from Git)")
+check!(articles_fields.include?("description"),
+       "articles must keep description for editorial deck copy")
+
+filename = posts["filename"].to_s
+check!(filename.include?("{year}") && filename.include?("{key}"),
+       "posts filename must be dated + key (got #{filename.inspect})")
+articles_filename = articles["filename"].to_s
+check!(articles_filename.include?("{year}") && articles_filename.include?("{key}"),
+       "articles filename must be dated + key (got #{articles_filename.inspect})")
+check!(posts.dig("view", "primary").to_s == "title",
+       "posts list primary should stay title (filename uses key separately)")
+check!(articles.dig("view", "primary").to_s == "title",
+       "articles list primary should stay title (filename uses key separately)")
+
+%w[posts articles].each do |name|
+  collection = name == "posts" ? posts : articles
+  key_field = (collection["fields"] || []).find { |field| field["name"].to_s == "key" }
+  check!(!key_field.nil?, "#{name} must define a key field")
+  check!(key_field["required"] == true, "#{name} key must be required for filename creation")
+end
+
+products = find_collection(config, "products")
+projects = find_collection(config, "projects")
+check!(!products.nil?, "missing products collection")
+check!(!projects.nil?, "missing projects collection")
+check!(products["filename"].to_s.include?("{key}"),
+       "products filename must use key (got #{products['filename'].inspect})")
+check!(projects["filename"].to_s.include?("{key}"),
+       "projects filename must use key (got #{projects['filename'].inspect})")
+
+pipeline = REPO_ROOT.join(".github/workflows/content-pipeline.yml").read
+on_push = pipeline[/\non:\n  push:\n(?:    .*\n)*/]
+check!(!on_push.nil? && !on_push.include?("paths:"),
+       "content-pipeline.yml on.push must not use paths: (CMS commits must always trigger)")
+check!(!pipeline.include?("MODE=skip"),
+       "content-pipeline.yml must not skip empty CMS commits: those still need an R2 publish")
+check!(pipeline.include?("if: github.ref == 'refs/heads/main'"),
+       "content-pipeline.yml must publish on main for push and manual run")
+check!(!pipeline.match?(/sveltia/i),
+       "content-pipeline.yml must not reference Sveltia")
+
+index = REPO_ROOT.join("studio/index.html").read
+check!(!index.include?("app.pagescms.org"),
+       "studio/index.html must not redirect to Pages CMS (AC-STU-08)")
+check!(!index.match?(/sveltia/i),
+       "studio/index.html must not load or mention Sveltia")
+check!(index.include?("studio-logo"),
+       "studio/index.html must use the Studio logo favicon")
+check!(index.include?('id="app"') || index.include?("src/main"),
+       "studio/index.html must mount the Studio SPA")
+
+api = REPO_ROOT.join("functions/api/studio/[[path]].js")
+check!(api.file?, "missing functions/api/studio/[[path]].js")
+api_src = api.read
+check!(api_src.include?("STUDIO_ALLOWLIST") || REPO_ROOT.join("functions/api/studio/_lib/auth.js").read.include?("STUDIO_ALLOWLIST"),
+       "Studio API must enforce STUDIO_ALLOWLIST")
+check!(REPO_ROOT.join("functions/api/studio/_lib/github.js").read.include?("GITHUB_TOKEN"),
+       "Studio API must use server-side GITHUB_TOKEN")
+check!(!api_src.include?("ghp_"), "API must not hardcode a GitHub PAT (AC-STU-09)")
+
+editor = REPO_ROOT.join("studio-app/src/editor/body-editor.js").read
+check!(editor.include?("autolink: false"),
+       "TipTap Link must set autolink: false (AC-STU-03)")
+check!(editor.include?("linkOnPaste: false"),
+       "TipTap Link must set linkOnPaste: false")
+
+puts "All Studio schema / shell checks passed."

data/scripts/test/test-template-packages.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Refs: PLT-AC-4 — each template ships README, template.yml, fixtures, screenshots.
+require "pathname"
+
+ROOT = Pathname.new(__dir__).join("../..").expand_path
+TEMPLATES = %w[cv articles blog media network bibliography portfolio].freeze
+TEMPLATES_ROOT = ROOT.join("templates")
+
+failed = false
+
+TEMPLATES.each do |name|
+  dir = TEMPLATES_ROOT.join(name)
+  unless dir.directory?
+    warn "FAIL test-template-packages: missing templates/#{name}/"
+    failed = true
+    next
+  end
+
+  readme = dir.join("README.md")
+  unless readme.file? && readme.read.strip.length.positive?
+    warn "FAIL test-template-packages: #{name} missing README.md"
+    failed = true
+  end
+
+  yaml = dir.join("template.yml")
+  unless yaml.file? && yaml.read.strip.length.positive?
+    warn "FAIL test-template-packages: #{name} missing template.yml"
+    failed = true
+  end
+
+  fixtures = dir.join("fixtures")
+  unless fixtures.directory? && fixtures.children.any? { |c| c.file? }
+    warn "FAIL test-template-packages: #{name} missing fixtures/ with sample files"
+    failed = true
+  end
+
+  screenshots = dir.join("screenshots")
+  has_shot_dir = screenshots.directory?
+  has_shot_asset = has_shot_dir && screenshots.children.any? do |c|
+    c.file? && (c.basename.to_s.match?(/\.(png|jpe?g|webp|gif)\z/i) || c.basename.to_s == "README.md" || c.basename.to_s == ".gitkeep")
+  end
+  unless has_shot_asset
+    warn "FAIL test-template-packages: #{name} missing screenshots/ (asset, README, or .gitkeep)"
+    failed = true
+  end
+end
+
+exit 1 if failed
+
+puts "PASS test-template-packages"

data/scripts/test/test-text-excerpt.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pathname"
+
+REPO_ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+require REPO_ROOT.join("_plugins/lib/text_excerpt").to_s
+
+def fail!(message)
+  warn message
+  exit 1
+end
+
+def check!(condition, message)
+  fail!(message) unless condition
+end
+
+puts "Testing TextExcerpt listing previews..."
+
+heading_body = <<~MD
+  ## Contexto
+
+  Os dados públicos do INSEE permitem medir os casamentos celebrados na França.
+MD
+
+excerpt = TextExcerpt.from_markdown(heading_body)
+check!(excerpt.start_with?("Contexto: Os dados públicos"),
+       "headings should become 'Title: ' prefixes (got #{excerpt.inspect})")
+
+long = "palavra " * 80
+truncated = TextExcerpt.from_markdown(long)
+check!(truncated.end_with?("..."), "long bodies must truncate with an ellipsis")
+check!(truncated.length <= 220, "truncated excerpt must stay within 220 characters")
+
+liquid = "{% include plotly.html src=\"/media/plots/x.html\" %}\n\nDepois do gráfico vem o texto."
+check!(TextExcerpt.from_markdown(liquid) == "Depois do gráfico vem o texto.",
+       "liquid includes must not leak into the excerpt")
+
+fields = TextExcerpt.listing_fields({ "description" => "  Deck editorial.  " }, heading_body)
+check!(fields["description"] == "Deck editorial.",
+       "listing_fields must keep the trimmed editorial description")
+check!(fields["excerpt"].start_with?("Contexto:"),
+       "listing_fields must still generate a body excerpt")
+
+empty_desc = TextExcerpt.listing_fields({ "description" => "" }, heading_body)
+check!(empty_desc["description"].empty?,
+       "empty editorial description stays empty in the index")
+check!(!empty_desc["excerpt"].empty?,
+       "empty editorial description still gets a generated excerpt")
+
+puts "All TextExcerpt checks passed."

data/scripts/test/test-unwrap-media-src.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+// Mirrors unwrapMediaSrc in content-runtime/10-utils.html and md-to-pdf.mjs.
+function unwrapMediaSrc(path) {
+  const value = String(path == null ? '' : path).trim();
+  if (!value) return '';
+  const md = value.match(/^\[([^\]]*)\]\(([^)\s]+)\)\s*$/);
+  if (md) return String(md[2] || '').trim();
+  const angle = value.match(/^<([^>\s]+)>\s*$/);
+  if (angle) return String(angle[1] || '').trim();
+  return value;
+}
+
+const cases = [
+  ['https://example.com/a.png', 'https://example.com/a.png'],
+  [
+    '[https://example.com/a.png](https://example.com/a.png)',
+    'https://example.com/a.png',
+  ],
+  ['[label](https://example.com/a.png)', 'https://example.com/a.png'],
+  ['<https://example.com/a.png>', 'https://example.com/a.png'],
+  ['media/images/a.png', 'media/images/a.png'],
+  ['[not a full](link) leftover', '[not a full](link) leftover'],
+  ['', ''],
+];
+
+let failed = 0;
+for (const [input, expected] of cases) {
+  const got = unwrapMediaSrc(input);
+  if (got !== expected) {
+    console.error(`FAIL: ${JSON.stringify(input)} → ${JSON.stringify(got)} (want ${JSON.stringify(expected)})`);
+    failed += 1;
+  }
+}
+
+if (failed) {
+  console.error(`unwrapMediaSrc: ${failed} failure(s)`);
+  process.exit(1);
+}
+console.log(`PASS: unwrapMediaSrc (${cases.length} cases)`);

data/scripts/test/test-unwrap-media-src.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Keep unwrapMediaSrc (Pages CMS Markdown-autolink mangling of include src=)
+# honest against a small Node mirror. The browser runtime and PDF exporter
+# share the same contract.
+
+require "pathname"
+require "open3"
+
+REPO_ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+SCRIPT = REPO_ROOT.join("scripts", "test", "test-unwrap-media-src.mjs")
+
+puts "Testing unwrapMediaSrc (CMS autolink unwrap)..."
+
+stdout, stderr, status = Open3.capture3("node", SCRIPT.to_s)
+print stdout
+warn stderr unless stderr.empty?
+exit(status.exitstatus)