@pajh/buldng 0.0.2 → 0.0.4

package/src/buldng-web.ts

@@ -0,0 +1,267 @@
+// buldng-web.ts
+// Pure runtime API for buldng. The optional renderer only writes text into a caller-owned element.
+
+let errorPage: string | null = null;
+let listenersInstalled = false;
+let redirectStarted = false;
+
+declare global {
+  interface Window {
+    __buldngErrorOverlay?: boolean;
+  }
+}
+
+const ERROR_STORAGE_PREFIX = "buldng:error:";
+
+export type ErrorPayload = {
+  id: string;
+  type: "error" | "unhandledrejection";
+  message: string;
+  stack: string;
+  time: string;
+  url: string;
+  userAgent: string;
+  platform: string;
+  language: string;
+};
+
+/**
+ * Configure the global error handler.
+ * @param url A full URL path like "/error/" or "/fatal/".
+ */
+export function setErrorPage(url: string) {
+  if (typeof url !== "string" || !url.length) {
+    throw new Error("setErrorPage: URL must be a non-empty string");
+  }
+
+  // Normalize: ensure no accidental double slashes
+  errorPage = url.endsWith("/") ? url.slice(0, -1) : url;
+
+  // Install global listeners once. Calling setErrorPage again only changes the destination.
+  installGlobalErrorHandler();
+}
+
+/**
+ * Internal: installs global error + unhandled rejection handlers.
+ */
+function installGlobalErrorHandler() {
+  if (!errorPage || listenersInstalled || isErrorPage() || window.__buldngErrorOverlay) return;
+
+  listenersInstalled = true;
+
+  window.addEventListener("error", (event) => {
+    handleError({
+      type: "error",
+      reason: event.error ?? event.message,
+      fallbackMessage: event.message,
+    });
+  });
+
+  window.addEventListener("unhandledrejection", (event) => {
+    handleError({
+      type: "unhandledrejection",
+      reason: event.reason,
+      fallbackMessage: "Unhandled promise rejection",
+    });
+  });
+}
+
+/**
+ * Read an error payload previously saved by the global handler.
+ * Defaults to the errorId query parameter on the current page.
+ */
+export function readErrorPayload(id = getErrorId()): ErrorPayload | null {
+  if (!id) return null;
+
+  try {
+    const raw = localStorage.getItem(storageKey(id));
+    if (!raw) return null;
+
+    const payload: unknown = JSON.parse(raw);
+    return isErrorPayload(payload) ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read and remove an error payload. Useful for one-shot error pages.
+ */
+export function consumeErrorPayload(id = getErrorId()): ErrorPayload | null {
+  const payload = readErrorPayload(id);
+  if (id) {
+    try {
+      localStorage.removeItem(storageKey(id));
+    } catch {
+      // Storage may be unavailable or blocked; the payload was still safely read if possible.
+    }
+  }
+  return payload;
+}
+
+/**
+ * Render a payload as safe text inside a caller-owned element.
+ * Returns the payload that was rendered, or null when it was unavailable.
+ */
+export function renderErrorPayload(
+  elementId: string,
+  payload = readErrorPayload()
+): ErrorPayload | null {
+  const container = document.getElementById(elementId);
+  if (!container) return null;
+
+  container.replaceChildren();
+  if (!payload) {
+    const empty = document.createElement("p");
+    empty.textContent = "Error details are no longer available.";
+    container.appendChild(empty);
+    return null;
+  }
+
+  const details: Array<[string, string]> = [
+    ["Type", payload.type],
+    ["Message", payload.message],
+    ["Time", payload.time],
+    ["Page", payload.url],
+    ["User agent", payload.userAgent],
+    ["Platform", payload.platform],
+    ["Language", payload.language],
+  ];
+
+  const list = document.createElement("dl");
+  for (const [label, value] of details) {
+    const term = document.createElement("dt");
+    term.textContent = label;
+    const description = document.createElement("dd");
+    description.textContent = value;
+    list.append(term, description);
+  }
+
+  if (payload.stack) {
+    const stackLabel = document.createElement("h3");
+    stackLabel.textContent = "Stack";
+    const stack = document.createElement("pre");
+    stack.textContent = payload.stack;
+    list.append(stackLabel, stack);
+  }
+
+  container.appendChild(list);
+  return payload;
+}
+
+/**
+ * Return the error record ID from the current URL.
+ */
+export function getErrorId(): string | null {
+  return new URLSearchParams(location.search).get("errorId");
+}
+
+function handleError(info: {
+  type: ErrorPayload["type"];
+  reason: unknown;
+  fallbackMessage: string;
+}) {
+  if (redirectStarted || !errorPage) return;
+  redirectStarted = true;
+
+  const payload = buildPayload(info);
+  const stored = saveErrorPayload(payload);
+  redirect(payload, stored);
+}
+
+function buildPayload(info: {
+  type: ErrorPayload["type"];
+  reason: unknown;
+  fallbackMessage: string;
+}): ErrorPayload {
+  const id = createId();
+  const error = info.reason instanceof Error ? info.reason : null;
+
+  return {
+    id,
+    type: info.type,
+    message: getErrorMessage(info.reason, info.fallbackMessage),
+    stack: error?.stack ?? getErrorStack(info.reason),
+    time: new Date().toISOString(),
+    url: location.href,
+    userAgent: navigator.userAgent,
+    platform: navigator.platform,
+    language: navigator.language,
+  };
+}
+
+/**
+ * Redirect to the configured error page with a storage key, plus a small fallback.
+ */
+function redirect(payload: ErrorPayload, stored: boolean) {
+  if (!errorPage) return;
+
+  const destination = new URL(errorPage, location.href);
+  if (stored) {
+    destination.searchParams.set("errorId", payload.id);
+  } else {
+    destination.searchParams.set("type", payload.type);
+    destination.searchParams.set("message", payload.message.slice(0, 500));
+  }
+
+  window.location.href = destination.href;
+}
+
+function saveErrorPayload(payload: ErrorPayload): boolean {
+  try {
+    localStorage.setItem(storageKey(payload.id), JSON.stringify(payload));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function storageKey(id: string) {
+  return `${ERROR_STORAGE_PREFIX}${id}`;
+}
+
+function createId() {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+function isErrorPage() {
+  const destination = new URL(errorPage!, location.href);
+  const destinationPath = destination.pathname.replace(/\/$/, "") || "/";
+  const currentPath = location.pathname.replace(/\/$/, "") || "/";
+  return destination.origin === location.origin && destinationPath === currentPath;
+}
+
+function getErrorMessage(reason: unknown, fallback: string) {
+  if (reason instanceof Error && reason.message) return reason.message;
+  if (typeof reason === "string" && reason) return reason;
+  if (reason !== null && reason !== undefined) {
+    try {
+      const text = JSON.stringify(reason);
+      if (text) return text;
+    } catch {
+      // Fall through to the stable message below.
+    }
+  }
+  return fallback;
+}
+
+function getErrorStack(reason: unknown) {
+  if (!reason || typeof reason !== "object") return "";
+  const stack = (reason as { stack?: unknown }).stack;
+  return typeof stack === "string" ? stack : "";
+}
+
+function isErrorPayload(value: unknown): value is ErrorPayload {
+  if (!value || typeof value !== "object") return false;
+  const payload = value as Partial<ErrorPayload>;
+  return typeof payload.id === "string"
+    && (payload.type === "error" || payload.type === "unhandledrejection")
+    && typeof payload.message === "string"
+    && typeof payload.stack === "string"
+    && typeof payload.time === "string"
+    && typeof payload.url === "string"
+    && typeof payload.userAgent === "string"
+    && typeof payload.platform === "string"
+    && typeof payload.language === "string";
+}

package/src/buldng.css

@@ -0,0 +1,148 @@
+/* --------------------------------------------------
+   LOCAL FONTS
+-------------------------------------------------- */
+@font-face {
+  font-family: Inter;
+  src: url("/assets/InterVariable.woff2") format("woff2");
+  font-weight: 100 900;
+  font-display: swap;
+}
+
+@font-face {
+  font-family: "JetBrains Mono";
+  src: url("/assets/JetBrainsMono-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-display: swap;
+}
+
+/* --------------------------------------------------
+   CAMERA GEOMETRY — JS-SIZED, CSS-LAID-OUT
+   Matches layout.ts:
+     CAM-PORTRAIT
+     CAM-LANDSCAPE-A
+     CAM-LANDSCAPE-B
+-------------------------------------------------- */
+
+#b-camera {
+  position: absolute;
+  inset: 0;
+  margin: auto;
+  container-type: size;
+  overflow: hidden;
+  background: var(--back);
+}
+
+/* --------------------------------------------------
+   CAMERA INTERNAL AREAS
+-------------------------------------------------- */
+
+#b-camera-style {
+  display: grid;
+  height: 100%;
+  width: 100%;
+  grid-template-areas:
+    "header"
+    "client"
+    "footer";
+}
+
+#b-top-bar {
+  grid-area: header;
+  overflow: hidden;
+  container-type: size;
+  width: 100%;
+}
+
+#b-client-area {
+  grid-area: client;
+}
+
+#b-bottom-bar {
+  grid-area: footer;
+  overflow: hidden;
+}
+
+/* --------------------------------------------------
+   PORTRAIT MODE
+   JS sets width/height; CSS sets layout only
+-------------------------------------------------- */
+
+.CAM-PORTRAIT#b-camera-style {
+  grid-template-rows: 20% auto 5%
+}
+
+/* --------------------------------------------------
+   LANDSCAPE-A MODE
+   JS sets width/height; CSS sets layout only
+-------------------------------------------------- */
+
+.CAM-LANDSCAPE-A#b-camera-style {
+  grid-template-rows: 15% 80% 5%;
+}
+
+/* --------------------------------------------------
+   LANDSCAPE-B MODE
+   JS sets width/height; CSS sets layout only
+-------------------------------------------------- */
+
+.CAM-LANDSCAPE-B#b-camera-style {
+  grid-template-rows: 15% 80% 5%;
+}
+
+/* --------------------------------------------------
+   GLOBAL THEME VARIABLES
+-------------------------------------------------- */
+:root[data-theme="light"] {
+  --back: #f7f7f7;
+  --panel: #ffffff;
+  --button: #f0f0f0;
+  --text: #222222;
+  --line: #9c9c9c;
+  --highlight1: #4aa3ff;
+  --highlight2: #ffd84a;
+  --logo-bg: #e0e0e0;
+  --logo-fg: #222;
+  --logo-shadow: 0 2px 4px rgb(0 0 0 0.15);
+}
+
+:root[data-theme="dark"] {
+  --back: #111111;
+  --panel: #1b1b1b;
+  --button: #4a4a4a;
+  --text: #eeeeee;
+  --line: #848484;
+  --highlight1: #4aa3ff;
+  --highlight2: #ffd84a;
+  --logo-bg: #333;
+  --logo-fg: #eee;
+  --logo-shadow: 0 2px 4px rgb(0 0 0 0.4);
+}
+
+/* --------------------------------------------------
+   GLOBAL BODY
+-------------------------------------------------- */
+html {
+  margin: 0;
+  padding: 0;
+  height:100%;
+  width:100%;
+}
+
+body { 
+  background: var(--back);
+  margin: 0;
+  padding: 0; 
+  height: 100%;
+  width: 100%;
+}
+
+html, body, button, input, select, textarea {
+    font-family: Inter, sans-serif;
+    font-size: var(--std-font-size);
+    color: var(--text);
+}
+
+button {
+  background: var(--button);
+}
+

package/src/clean.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+set -euo pipefail
+
+# Sentinel must exist in the current directory
+if [ ! -f BULDNG_DEST ]; then
+    echo "clean.sh: refusing — sentinel missing"
+    exit 1
+fi
+
+# Delete everything in the current directory, including subdirectories
+rm -rf ./*
+
+# Delete the script itself
+rm -f "$0"

package/src/layout.ts

@@ -0,0 +1,184 @@
+/* --------------------------------------------------
+   GLOBAL VIEWPORT STATE
+-------------------------------------------------- */
+function applyCameraSize(mode: string) {
+  const cam = document.getElementById("b-camera");
+  if (!cam) return;
+
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+
+  let width, height;
+
+  if (mode === "PORTRAIT") {
+    height = vh;
+    width = vw;
+  } else if (mode === "LANDSCAPE_A") {
+    height = vh;
+    width = vh * 4/3;
+  } else {
+    // LANDSCAPE_B
+    width = vw;
+    height = vw * 3/4;
+  }
+
+  cam.style.width = `${width}px`;
+  cam.style.height = `${height}px`;
+
+  // Center WITHOUT transform (no containing-block issues)
+  cam.style.position = "absolute";
+  cam.style.top = "0";
+  cam.style.bottom = "0";
+  cam.style.left = "0";
+  cam.style.right = "0";
+  cam.style.margin = "auto";
+}
+
+export const buldrViewport = {
+  width: window.innerWidth,
+  height: window.innerHeight,
+  aspect: window.innerWidth / window.innerHeight,   // w/h
+  mode: "PORTRAIT", // PORTRAIT | LANDSCAPE_A | LANDSCAPE_B
+};
+
+/* --------------------------------------------------
+   MODE COMPUTATION
+-------------------------------------------------- */
+
+function computeMode() {
+  const a = buldrViewport.aspect;
+
+  if (a >= 4/3) return "LANDSCAPE_A";
+  if (a <= 3/4) return "PORTRAIT";
+  return "LANDSCAPE_B";
+}
+
+/* --------------------------------------------------
+   APPLY CAMERA MODE CLASS
+-------------------------------------------------- */
+
+function applyCameraMode(mode: string) {
+  const cam  = document.getElementById("b-camera");
+  if (!cam) return;
+  const style = document.getElementById("b-camera-style");
+  if (!style) return;
+
+  // Remove all camera classes
+  cam.classList.remove("CAM-PORTRAIT", "CAM-LANDSCAPE-A", "CAM-LANDSCAPE-B");
+  style.classList.remove("CAM-PORTRAIT", "CAM-LANDSCAPE-A", "CAM-LANDSCAPE-B");
+  // Add the new one
+  if (mode === "PORTRAIT") {
+    cam.classList.add("CAM-PORTRAIT");
+    style.classList.add("CAM-PORTRAIT");  
+  } else if (mode === "LANDSCAPE_A") {
+    cam.classList.add("CAM-LANDSCAPE-A");
+    style.classList.add("CAM-LANDSCAPE-A");
+  } else {
+    cam.classList.add("CAM-LANDSCAPE-B");
+    style.classList.add("CAM-LANDSCAPE-B");
+  }
+}
+
+/* --------------------------------------------------
+   APPLY GLOBAL CSS MODE (PORTRAIT / LANDSCAPE)
+-------------------------------------------------- */
+function applyCssMode(mode: string) {
+  const html = document.documentElement;
+
+  if (mode === "PORTRAIT") {
+    html.classList.remove("LANDSCAPE");
+    html.classList.add("PORTRAIT");
+  } else {
+    html.classList.remove("PORTRAIT");
+    html.classList.add("LANDSCAPE");
+  }
+}
+/* --------------------------------------------------
+   FONT SIZE COMPUTATION (NEW)
+-------------------------------------------------- */
+
+const FACTOR_PORTRAIT     = 0.035;
+const FACTOR_LANDSCAPE_B  = 0.035;
+const FACTOR_LANDSCAPE_A  = 0.020;
+
+function applyFontSize(mode: string) {
+  const cam = document.getElementById("b-camera");
+  if (!cam) return;
+
+  const camWidth = cam.getBoundingClientRect().width;
+
+  let factor = FACTOR_PORTRAIT;
+  if (mode === "LANDSCAPE_A") factor = FACTOR_LANDSCAPE_A;
+  else if (mode === "LANDSCAPE_B") factor = FACTOR_LANDSCAPE_B;
+
+  const size = camWidth * factor;
+
+  document.documentElement.style.setProperty("--std-font-size", `${size}px`);
+}
+
+/* --------------------------------------------------
+   UPDATE + DEBUG
+-------------------------------------------------- */
+
+function updateViewportInfo() {
+  buldrViewport.width = window.innerWidth;
+  buldrViewport.height = window.innerHeight;
+  buldrViewport.aspect = window.innerWidth / window.innerHeight;
+
+  const mode = computeMode();
+  buldrViewport.mode = mode;
+
+  console.log(
+    `[BULDR] viewport ${buldrViewport.width}x${buldrViewport.height}, `
+    + `aspect=${buldrViewport.aspect.toFixed(3)}, `
+    + `mode=${mode}`
+  );
+
+  applyCameraMode(mode);
+  applyCssMode(mode);
+  applyCameraSize(mode); 
+  applyFontSize(mode);  
+}
+
+/* --------------------------------------------------
+   THEME
+-------------------------------------------------- */
+
+function initTheme() {
+  const btn = document.getElementById("theme-toggle");
+  if (!btn) return;
+
+  const current = localStorage.getItem("theme") || "light";
+  document.documentElement.dataset.theme = current;
+
+  btn.addEventListener("click", () => {
+    const next = document.documentElement.dataset.theme === "light" ? "dark" : "light";
+    document.documentElement.dataset.theme = next;
+    localStorage.setItem("theme", next);
+  });
+}
+
+/* --------------------------------------------------
+   VIEWPORT LISTENER
+-------------------------------------------------- */
+
+function initViewportListener() {
+  updateViewportInfo(); // initial
+
+  window.addEventListener("resize", () => {
+    updateViewportInfo();
+  });
+}
+
+/* --------------------------------------------------
+   LAYOUT INIT
+-------------------------------------------------- */
+
+function initLayout() {
+  initTheme();
+  initViewportListener();
+}
+
+// Run layout immediately
+initLayout();
+window.__ready._resolveA();

package/src/types/global.d.ts

@@ -0,0 +1,10 @@
+export {};
+
+declare global {
+  interface Window {
+    __ready: {
+      a: Promise<void>;
+      _resolveA: () => void;
+    };
+  }
+}

package/src/workfile.js

@@ -0,0 +1,69 @@
+// --------------------------------------------------
+// WorkFile — immutable, lazy, tree-structured build node
+// --------------------------------------------------
+
+import fs from "node:fs";
+import path from "node:path";
+import esbuild from "esbuild";
+import { assertDestWrite } from "./buldng-lib.js";
+import { OPS } from "./buldng-ops.js";
+
+export class WorkFile {
+  constructor(op, config = {}, children = [], tag = null) {
+    if (!OPS[op]) {
+        throw new Error(`Invalid WorkFile op "${op}" — not one of: ${Object.keys(OPS).join(", ")}`);
+    }
+    this.op = op;               // "file", "literal", "append", "replace", "compile"
+    this.config = Object.freeze(config);
+    this.children = Object.freeze(children);
+    this.tag = tag;             // optional tag
+    Object.freeze(this);        // full immutability
+  }
+  
+  // --------------------------------------------------
+  // execute(): recursively produce output string
+  // --------------------------------------------------
+  execute() {
+      return OPS[this.op](this.config, this.children);
+    
+  }
+  
+  // --------------------------------------------------
+  // save(): write output to disk
+  // --------------------------------------------------
+  save(target) {
+    if (!target) {
+      throw new Error("WorkFile.save(): target filename required");
+    }
+    
+    const abs = assertDestWrite(target);
+    const out = this.execute();
+    
+    // If file exists, enforce integrity rule
+    if (fs.existsSync(abs)) {
+      const existing = fs.readFileSync(abs, "utf8");
+      
+      if (existing === out) {
+        // Byte-identical → warn but allow
+        console.warn(
+          `WorkFile.save(): attempted to overwrite '${target}' with identical content — continuing`
+        );
+        return "/" + target;
+      }
+      
+      // Different → fatal error
+      throw new Error(
+        `WorkFile.save(): cannot overwrite '${target}' — existing file differs from generated output`
+      );
+    }
+    
+    // File does not exist → write it
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, out, "utf8");
+    // NEW: mark file read-only
+    fs.chmodSync(abs, 0o444);
+    
+    console.log(`save: ${abs}`);
+    return "/" + target;
+  }
+}