stylegallery 0.1.6 → 0.1.8

package/scripts/compiler/operations.mjs

@@ -0,0 +1,70 @@
+import { z } from "zod";
+
+export const upstream = Object.freeze({
+  repository: "https://github.com/changeroa/site-compiler",
+  verified_revision: "371849141ba68d12d578c804cc53fe7267c899b0",
+  verified_at: "2026-09-22",
+});
+
+const text = z.string().min(1).refine((value) => !value.includes("\0"), "must not contain NUL");
+const file = text.describe("Filesystem path; relative paths resolve from the SG caller's working directory.");
+const positive = z.number().int().positive();
+const url = z.url().refine((value) => ["http:", "https:"].includes(new URL(value).protocol), "use an HTTP or HTTPS URL");
+const optional = (shape) => Object.fromEntries(Object.entries(shape).map(([key, value]) => [key, value.optional()]));
+const viewport = { width: positive.max(16384), height: positive.max(16384), wait: z.number().int().min(0).max(60000) };
+const capture = { ...viewport, step: positive, quality: positive.max(100), grow: z.boolean() };
+const batch = { only: text, force: z.boolean(), parallel: positive.max(32), timeout_ms: positive };
+const model = { ...batch, model: text, timeout_ms: positive, stylegallery: file };
+const operation = (script, description, required, options = {}, paths = [], extra = {}) => ({
+  script, description, paths,
+  schema: z.strictObject({ ...required, ...optional(options), runner_timeout_ms: positive.max(21600000).optional() }),
+  ...extra,
+});
+
+// This registry owns both public transports. Upstream scripts remain in the
+// separately installed checkout and are never admitted as gallery material.
+export const compilerOperations = Object.freeze({
+  compile: operation("compile.mjs", "Capture a live website as scenes.json, scene frames, and mounted text. Writes to out; does not transcribe the frames.",
+    { url, out: file }, { ...viewport, substep: positive }, ["out"]),
+  timeline: operation("timeline.mjs", "Capture dense scroll frames and a pixel-difference curve. Writes timeline-curve.json and dense/ to out.",
+    { url, out: file }, { ...capture, max_height: positive }, ["out"]),
+  transcribe: operation("transcribe.mjs", "Transcribe captured packs into SceneBook and Timeline documents using the installed Claude CLI. May incur model usage. Inspect transcribe.json for per-pack outcomes.",
+    { in: file }, { ...model, image_budget: positive, phase: z.enum(["both", "scenebook", "timeline"]) }, ["in", "stylegallery"], { ledger: "transcribe.json" }),
+  sale: operation("sale-edition.mjs", "Generate a sale edition and a private copy audit from transcribed documents. Does not publish or establish rights clearance.",
+    { in: file, out: file }, { audit: file }, ["in", "out", "audit"]),
+  gate: operation("qa-gate.mjs", "Check capture/transcription consistency and optionally a sale edition. A failed gate returns a nonzero exit code; json optionally writes the report.",
+    { in: file }, { sale: file, json: file, max_gap_ratio: z.number().min(0).max(1), max_gaps_per_scene: z.number().int().min(0), static_score: z.number().min(0), high_score: z.number().min(0) }, ["in", "sale", "json"]),
+  build: operation("build.mjs", "Build package previews from sale editions with original-page and external-media access restricted. Not the faithful-reconstruction route. Uses the installed Claude CLI and may incur model usage. Inspect build.json for per-pack outcomes.",
+    { packs: file, out: file }, model, ["packs", "out", "stylegallery"], { ledger: "build.json" }),
+  shots: operation("shots.mjs", "Render built sites into desktop/mobile screenshots and a reduced-motion report under each build's shots/ directory.",
+    { slug: text, builds: file }, { steps: positive.max(1000) }, ["builds"]),
+  probe: operation("probe-scroll.mjs", "Inspect website scroll geometry with Chromium; chrome selects installed Chrome. Returns the upstream diagnostic log.",
+    { url }, { chrome: z.boolean() }, [], { positional: ["url"] }),
+  "batch-triage": operation("batch-triage.mjs", "Capture candidate sites for triage. Inspect runs.json for individual failures even when the process exits successfully.",
+    { candidates: file, out: file }, { ...batch, step: positive, wait: viewport.wait, quality: capture.quality, grow: z.boolean() }, ["candidates", "out"], { ledger: "runs.json" }),
+  triage: operation("triage.mjs", "Rank captured scroll curves and write a triage report. This is heuristic ranking, not product verification.",
+    { in: file }, { json: file, md: file, min_height: positive, pin_score: z.number().min(0), spike_score: z.number().min(0) }, ["in", "json", "md"]),
+  "batch-capture": operation("batch-capture.mjs", "Capture scenes and timelines for candidate sites. Inspect capture.json for per-pack outcomes.",
+    { candidates: file, out: file }, { ...batch, step: positive, quality: capture.quality }, ["candidates", "out"], { ledger: "capture.json" }),
+  "pack-status": operation("pack-status.mjs", "Update pack status, generating sale editions and running gates as needed. Writes status reports into in.",
+    { candidates: file, in: file }, { force: z.boolean() }, ["candidates", "in"]),
+  "pack-release": operation("pack-release.mjs", "Package products from the compiler checkout's out/packs and out/builds into out/release. Replaces matching release folders and ZIP files locally; does not upload or publish.",
+    { products: file }, { only: text }, ["products"]),
+});
+
+export const workflowSchema = z.strictObject({ document: z.enum(["workflow", "readme"]).default("workflow") });
+
+export function compilerToolDefinitions() {
+  return Object.entries(compilerOperations).map(([name, operation]) => {
+    const { $schema, ...inputSchema } = z.toJSONSchema(operation.schema);
+    return {
+      name, description: operation.description, inputSchema,
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    };
+  }).concat({
+    name: "workflow",
+    description: "Read the installed compiler's current workflow or README with revision and content hash, plus the SG component and motion contract routes.",
+    inputSchema: { type: "object", properties: { document: { type: "string", enum: ["workflow", "readme"], default: "workflow" } }, additionalProperties: false },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+  });
+}

package/scripts/compiler/runtime.mjs

@@ -0,0 +1,156 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { compilerOperations, compilerToolDefinitions, upstream, workflowSchema } from "./operations.mjs";
+
+const galleryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const logLimit = 65536;
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const handoff = { consumer_reference: "consumer-reference/agent-native/registry.json" };
+
+export function failure(operation, code, message) {
+  return { ok: false, operation, failures: [{ code, message }] };
+}
+
+function compilerLocation(config) {
+  const configured = config.compilerRoot ?? process.env.SG_COMPILER_ROOT;
+  if (!configured) throw Object.assign(new Error("Set SG_COMPILER_ROOT to your site-compiler checkout, or pass --compiler-root to the CLI."), { code: "compiler_not_configured" });
+  const root = fs.realpathSync(path.resolve(config.cwd ?? process.cwd(), configured));
+  const manifest = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+  if (manifest.name !== "site-compiler") throw Object.assign(new Error("SG_COMPILER_ROOT must contain the site-compiler package."), { code: "compiler_invalid" });
+  const revision = spawnSync("git", ["-C", root, "rev-parse", "HEAD"], { encoding: "utf8", timeout: 5000 });
+  const gitRoot = spawnSync("git", ["-C", root, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 5000 });
+  const isCheckout = gitRoot.status === 0 && fs.realpathSync(gitRoot.stdout.trim()) === root;
+  const status = isCheckout ? spawnSync("git", ["-C", root, "status", "--porcelain", "--untracked-files=no"], { encoding: "utf8", timeout: 5000 }) : null;
+  const actualRevision = isCheckout && revision.status === 0 ? revision.stdout.trim() : null;
+  return {
+    root, package_version: manifest.version, revision: actualRevision,
+    tracked_changes: status?.status === 0 ? status.stdout.length > 0 : null,
+    matches_verified_revision: actualRevision === upstream.verified_revision && status?.status === 0 && status.stdout.length === 0,
+  };
+}
+
+export function compilerDiscovery(config = {}) {
+  let installation;
+  try { installation = { configured: true, ...compilerLocation(config) }; }
+  catch (error) { installation = { configured: false, code: error.code ?? "compiler_unavailable", message: error.message }; }
+  return {
+    ...upstream, installation,
+    operations: compilerToolDefinitions(),
+    contracts: ["design-engineering/component-contract.md", "motion/observed-choreography.md"],
+    ...handoff,
+  };
+}
+
+function checkedFile(root, name) {
+  const target = path.join(root, name);
+  if (fs.realpathSync(target) !== target || !fs.statSync(target).isFile()) {
+    throw Object.assign(new Error(`Compiler entry must be a regular file within its checkout: ${name}`), { code: "compiler_entry_invalid" });
+  }
+  return target;
+}
+
+function runProcess(script, args, { cwd, timeout, signal }) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve({ exit_code: null, signal: null, cancelled: true, timed_out: false, stdout: "", stderr: "" });
+    const child = spawn(process.execPath, [script, ...args], {
+      cwd, shell: false, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"],
+    });
+    const logs = { stdout: Buffer.alloc(0), stderr: Buffer.alloc(0) };
+    const truncated = { stdout: false, stderr: false };
+    let timedOut = false;
+    let cancelled = false;
+    let spawnError;
+    let forceTimer;
+    const kill = (signalName) => {
+      try {
+        if (process.platform === "win32" && child.pid) {
+          spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 5000 });
+        }
+        else if (child.pid) process.kill(-child.pid, signalName);
+      } catch (error) { if (error.code !== "ESRCH") spawnError ??= error.message; }
+    };
+    const stop = () => {
+      kill("SIGTERM");
+      forceTimer ??= setTimeout(() => kill("SIGKILL"), 1000);
+      forceTimer.unref();
+    };
+    const abort = () => { cancelled = true; stop(); };
+    const timer = setTimeout(() => { timedOut = true; stop(); }, timeout);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    for (const channel of ["stdout", "stderr"]) child[channel].on("data", (chunk) => {
+      const combined = Buffer.concat([logs[channel], chunk]);
+      truncated[channel] ||= combined.length > logLimit;
+      logs[channel] = combined.subarray(Math.max(0, combined.length - logLimit));
+    });
+    child.on("error", (error) => { spawnError = error.message; });
+    child.on("close", (exitCode, exitSignal) => {
+      clearTimeout(timer);
+      if (forceTimer) { kill("SIGKILL"); clearTimeout(forceTimer); }
+      signal?.removeEventListener("abort", abort);
+      resolve({
+        exit_code: exitCode, signal: exitSignal, timed_out: timedOut, cancelled,
+        stdout: logs.stdout.toString("utf8"), stderr: logs.stderr.toString("utf8"),
+        stdout_truncated: truncated.stdout, stderr_truncated: truncated.stderr,
+        ...(spawnError ? { spawn_error: spawnError } : {}),
+      });
+    });
+  });
+}
+
+export async function executeCompiler(operation, input = {}, config = {}) {
+  const spec = Object.hasOwn(compilerOperations, operation) ? compilerOperations[operation] : null;
+  if (!spec && operation !== "workflow") return failure(operation, "command_unknown", `Unknown compiler command: ${operation}`);
+  const parsed = (operation === "workflow" ? workflowSchema : spec.schema).safeParse(input);
+  if (!parsed.success) return failure(operation, "input_invalid", parsed.error.message);
+  try {
+    const compiler = compilerLocation(config);
+    if (operation === "workflow") {
+      const name = parsed.data.document === "readme" ? "README.md" : "SKILL.md";
+      const bytes = fs.readFileSync(checkedFile(compiler.root, name));
+      return { ok: true, operation, result: { compiler, source: name, sha256: hash(bytes), text: bytes.toString("utf8"), contracts: compilerDiscovery(config).contracts, ...handoff } };
+    }
+    const script = checkedFile(compiler.root, spec.script);
+    const scriptHash = hash(fs.readFileSync(script));
+    const values = { ...parsed.data };
+    const timeout = values.runner_timeout_ms ?? 1800000;
+    delete values.runner_timeout_ms;
+    if (operation === "transcribe" || operation === "build") values.stylegallery ??= galleryRoot;
+    for (const key of spec.paths) if (values[key] !== undefined) values[key] = path.resolve(config.cwd ?? process.cwd(), values[key]);
+    if (operation === "sale") {
+      if (values.in === values.out) return failure(operation, "input_invalid", "sale requires a separate output directory.");
+      values.audit ??= path.join(path.dirname(values.out), "copy-audit.private.json");
+      const relative = path.relative(values.out, values.audit);
+      if (relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative))) {
+        return failure(operation, "input_invalid", "The private copy audit must be outside the sale directory.");
+      }
+    }
+    const args = [];
+    for (const key of spec.positional ?? []) args.push(values[key]);
+    for (const [key, value] of Object.entries(values)) {
+      if (spec.positional?.includes(key) || value === false) continue;
+      args.push(`--${key.replaceAll("_", "-")}`);
+      if (value !== true) args.push(String(value));
+    }
+    const execution = await runProcess(script, args, { cwd: compiler.root, timeout, signal: config.signal });
+    const ok = execution.exit_code === 0 && !execution.timed_out && !execution.cancelled && !execution.spawn_error;
+    const result = {
+      compiler, script: spec.script, script_sha256: scriptHash,
+      arguments: args, paths: Object.fromEntries(spec.paths.filter((key) => values[key] !== undefined).map((key) => [key, values[key]])),
+      ...execution, ...handoff,
+      ...(spec.ledger ? { ledger: path.join(values.out ?? values.in, spec.ledger), success_scope: "process_exit_only; inspect ledger for each pack" } : {}),
+      ...(operation === "pack-release" ? { output: path.join(compiler.root, "out/release") } : {}),
+    };
+    return {
+      ok, operation, result,
+      ...(!ok ? { failures: [{
+        code: execution.cancelled ? "compiler_cancelled" : execution.timed_out ? "compiler_timeout" : "compiler_failed",
+        message: execution.spawn_error ?? (execution.cancelled ? "Compiler execution cancelled." : execution.timed_out ? `Compiler exceeded ${timeout}ms.` : `Compiler exited with ${execution.exit_code ?? execution.signal}.`),
+      }] } : {}),
+    };
+  } catch (error) { return failure(operation, error.code ?? "compiler_unavailable", error.message); }
+}

package/scripts/sg-entry.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+try {
+  const { runSgCli } = await import("./compiler/cli.mjs");
+  const controller = new AbortController();
+  const cancel = () => controller.abort();
+  process.once("SIGINT", cancel);
+  process.once("SIGTERM", cancel);
+  try {
+    const result = await runSgCli(process.argv.slice(2), { signal: controller.signal });
+    process.stdout.write(result.output);
+    process.exitCode = result.exitCode;
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    process.removeListener("SIGTERM", cancel);
+  }
+} catch (error) {
+  process.stdout.write(`${JSON.stringify({ ok: false, operation: null, failures: [{ code: error.code ?? "cli_failed", message: error.message }] }, null, 2)}\n`);
+  process.exitCode = 1;
+}

package/scripts/sg-server.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createSgMcpServer } from "./compiler/mcp.mjs";
+
+try {
+  const controller = new AbortController();
+  const server = createSgMcpServer({ signal: controller.signal });
+  const shutdown = () => {
+    controller.abort();
+    server.close().catch(() => {});
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  process.stdin.once("end", shutdown);
+  await server.connect(new StdioServerTransport());
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+}

package/showcase/README.md

@@ -0,0 +1,113 @@
+---
+type: Showcase Guide
+title: Showcase
+description: Free-form, single-page expressive works checked by outcome instead of authoring rules.
+lifecycle: experimental
+---
+
+# Showcase
+
+Primary role: expressive work area.
+
+`showcase/` holds complete, expressive pages: brand studies, landing pages, and art-directed experiments. The Layout authoring rules do not apply here. A work may use any CSS property, any selector, gradients, blend modes, WebGL, GSAP, Lenis, or its own fonts. Layout still sets the floor: a work has to pass the outcome checks below. It does not have to follow the pattern CSS style guide.
+
+## Why It Exists
+
+Reusable Layout patterns exclude decorative styling so they stay portable. That rule is correct for `patterns/**`, but it made the repository unable to express a finished product page. Showcase is the product layer where the finished page lives. It depends on Layout and Expression. Nothing depends on it.
+
+## Work Contract
+
+Each work is one directory, `showcase/<slug>/`, containing:
+
+- `index.html`: the entry page. It may load local files or pinned CDN libraries.
+- `brief.md`: the direction, frontmatter with `type: Showcase Brief`, `title`, `description`, and `brand_study: true|false`.
+- Any other local assets the page needs.
+
+A brand study (`brand_study: true`) reinterprets a named real brand. It additionally requires:
+
+- `subject:` in the brief frontmatter, naming the brand being studied.
+- `<meta name="robots" content="noindex, nofollow">` in `index.html`.
+- Visible text containing "Unofficial" on the page.
+- No copied logos, trademarks as artwork, or verbatim marketing copy. Write original copy in the brand's register instead.
+
+See [Brand Studies](../expression/brand-studies.md) for the reasoning and limits.
+
+## Brief Template
+
+```md
+---
+type: Showcase Brief
+title: <Work name>
+description: <One sentence: what the page is and what it should feel like.>
+brand_study: false
+---
+
+# <Work name>
+
+## Direction
+Reference, mood, and the one thing a visitor should remember.
+
+## System
+Type pairing, palette, texture, and motion density, with actual values or a link to an Expression direction.
+
+## Techniques
+Expression and Motion technique pages the work uses.
+
+## Layout Floor
+Scroll owner, pinned or sticky regions, and how the page collapses at 320px.
+```
+
+## Preview
+
+```sh
+bun run showcase:serve              # http://localhost:4180/ (hub) and one URL per work
+bun run showcase:serve -- --port 4190
+```
+
+Working on a remote machine over SSH? Run this on your own machine, then open `http://localhost:4180/` in your local browser:
+
+```sh
+ssh -N -L 4180:127.0.0.1:4180 <user>@<remote-host>
+```
+
+The serve command prints this line with the right user and host filled in. Fonts and libraries load from CDNs in the visitor's browser, so the local machine needs internet access.
+
+Once any work exists, `showcase/index.html` is the hub that lists every work: the first work creates it, every later work adds a card, and each work's footer links back to `../`.
+
+## Outcome Checks
+
+`bun run test:showcase` (or `node scripts/check-showcase.mjs --work <slug>`) runs the hub and every work in headless Chromium. Each check maps to a scenario in the [QA contract](QA.md):
+
+| Check | Failure |
+| --- | --- |
+| Brief contract | Missing brief fields, or a brand study without `subject`, `noindex`, or visible "Unofficial" text. |
+| Runtime and assets | Any uncaught page error, or any same-origin request answered with 4xx. Failed CDN requests alone are tolerated. |
+| Horizontal overflow | Document wider than the viewport at 320, 768, or 1440 CSS pixels, at the top, middle, or bottom. |
+| Focus | A tabbable element with no box, outside the viewport, covered by another element (such as a sticky header), or reached out of DOM order. |
+| Reduced motion | With `prefers-reduced-motion: reduce`, a heading or paragraph invisible on arrival, or an infinite animation running. |
+| Contrast | Text over a solid background below WCAG AA: 4.5:1, or 3:1 for large text. |
+| Links and actions | A link to raw Markdown, an empty `#`, a missing `#id`, or `#top` outside the header; a `[data-demo]` action that is not a button, shows no visible `role="status"` message, or moves the page. |
+| Identity | No title or no favicon. |
+| Hash navigation | Clicking the first header nav link does not update the URL hash or lands its heading under the header or below the top half; Back does not return near the top; opening the last nav target's URL directly does not land on it. |
+| Short viewport | At 1280x620, a fixed or pinned element that contains text is taller than the viewport. |
+| Offscreen ambient | At 1440 wide, an infinite CSS animation or repeating GSAP tween still running on an element entirely offscreen. Mark ambient containers `data-ambient` and pause them with an IntersectionObserver. |
+| Offline | With every non-local request blocked: page errors, hidden text, or overflow at 390 wide. |
+| No script | With every script blocked: hidden text or overflow at 390 wide. |
+| Hub | Works exist but `showcase/index.html` is missing, or a work directory it does not link. With no works, the check passes and reports that there is nothing to check. |
+
+Fictional actions (subscribe, book, get a key) must be `<button type="button" data-demo="...">` elements that show an honest message in a `role="status"` region, never links that jump to the top.
+
+Screenshots are taken after entrance tweens and CSS transitions settle and are written to `.tmp/showcase/<slug>/`. The checks do not judge taste: review the screenshots. `bun run test:showcase:self` proves each check can fail by running the checker against fixtures built to violate it.
+
+## Works
+
+The repository ships the contract, the checker, and the guidance, but no committed works. Works are built per project in `showcase/<slug>/` and must pass the checks above before they are shared.
+
+## Starting A Work Fast
+
+Read this page, one [Expression direction](../expression/index.md), and the [Motion techniques](../motion/techniques/scroll-choreography.md) you need. Skip governance, provenance, and consumer-reference documents: a showcase work creates no governed record. Build, add a hub card, run `bun run showcase:serve` and `node scripts/check-showcase.mjs --work <slug>`, look at the screenshots, and iterate.
+
+## IA Navigation
+
+Parent: [StyleGallery](../index.md).
+Next: [Expression](../expression/index.md).

package/game-ui/classification.md

@@ -1,82 +0,0 @@
----
-type: Domain Guide
-title: Game UI Classification
-description: Engine-neutral method for classifying game interfaces by player task, presentation, input, state, and motion.
-domain: game-ui
-lifecycle: experimental
----
-
-# Game UI Classification
-
-Primary role: game-interface classification guide.
-
-## Repository Boundary
-
-This guide proposes a local, project-neutral taxonomy for classifying observable game-interface behavior without assuming a specific engine or art direction. Its player-task classes and classification axes are review tools, not a universal ontology. It does not turn a visual genre into a functional category or authorize decorative properties in reusable Layout patterns.
-
-## Reusable Method
-
-1. Capture the rendered screen or interaction in context.
-2. Assign one primary player-task class.
-3. Add secondary classes only when the same surface genuinely composes responsibilities.
-4. Record visual language, input, state, motion, and implementation as separate axes.
-5. Attach evidence for default, exceptional, and transitional states.
-6. State what is observed, inferred, and still unverified.
-
-## Player-Task Classes
-
-| Primary class | Player question | Typical examples |
-| --- | --- | --- |
-| `hud` | What is happening during play right now? | Health, ammo, objective, marker, cooldown |
-| `navigation` | Where can I go next? | Main menu, pause menu, chapter or mode selection |
-| `dialog` | What decision or interruption needs attention? | Confirmation, reconnect, privacy, system notice |
-| `inventory` | What do I own, equip, compare, or improve? | Loadout, stash, equipment, crafting, upgrade |
-| `progression` | What did I unlock or how am I advancing? | Results, level up, rewards, rank change |
-| `commerce` | What can I acquire and at what cost? | Shop, offer, product detail, currency shortage |
-| `tutorial` | What action should I learn or perform? | Coach mark, forced step, contextual hint |
-| `narrative` | What story or authored event is being presented? | Dialogue, boss intro, cinematic overlay |
-| `system-status` | Is the application ready and connected? | Splash, loading, sign-in, reconnect, patch status |
-| `input-surface` | How do I directly control the game? | Virtual stick, action button, key binding |
-
-## Classification Axes
-
-| Axis | Example values | Evidence requirement |
-| --- | --- | --- |
-| World relationship | `diegetic`, `spatial`, `overlay`, `full-screen` | Capture placement relative to play space |
-| Material character | `flat-graphic`, `framed`, `skeuomorphic`, `translucent`, `textural` | Capture repeated surface treatment |
-| Genre signal | `tactical`, `industrial`, `fantasy-ornamental`, `arcade`, `horror`, `casual` | Show repeated shape, type, icon, and material cues |
-| Information density | `sparse`, `standard`, `dense` | Count simultaneous choices and information groups |
-| Emphasis model | `typographic`, `icon-led`, `character-led`, `item-led`, `effect-led` | Identify first and second attention targets |
-| Input | pointer, keyboard, gamepad, touch, gaze, mixed | Exercise every declared input mode |
-| Motion role | affordance, activation, state change, transition, value change, reward, guidance, ambient | Record trigger, properties, timing, and interruption |
-
-## Opinionated Guidance
-
-- Organize the gallery first by player task, then filter by presentation and implementation axes.
-- Use two or three visual tags supported by repeated evidence.
-- Classify independent player-task regions separately when a screen composes them.
-- Do not infer style or behavior from project, prefab, widget, scene, or class names alone.
-
-## Platform-Specific Guidance
-
-Record engine, UI framework, render space, scaling policy, navigation system, text system, and motion system as implementation evidence. Route detailed engine hierarchy and API guidance to the matching engine-specific Game UI guide.
-
-## Unsupported Absolutes
-
-- A genre label does not establish a visual style.
-- A screenshot does not prove responsive behavior, focus behavior, or motion interruption.
-- A production project's folder structure is not a universal architecture.
-- Similar appearance does not prove equivalent accessibility, performance, or interaction behavior.
-
-## Verification Contract
-
-Verify narrow and wide surfaces, every declared input mode, long localized text, empty and loading states, disabled and error states, repeated open and close, rapid selection changes, and interrupted motion where relevant.
-
-## Source, License, And Attribution
-
-This page is a locally authored, project-neutral proposed taxonomy. It reproduces no game assets, project-specific hierarchy, or upstream implementation samples.
-
-## IA Navigation
-
-Parent: [Game UI](index.md).
-Next: [Game UI Screen Hierarchy](screen-hierarchy.md).

package/game-ui/decision-tree.md

@@ -1,81 +0,0 @@
----
-type: Domain Guide
-title: Game UI Decision Tree
-description: Select player-task recipes, ownership boundaries, and engine routes from the screen's purpose.
-domain: game-ui
-lifecycle: experimental
-provenance_kind: local
----
-
-# Game UI Decision Tree
-
-Primary role: game screen planning route.
-
-## Repository Boundary
-
-This route selects game-interface responsibilities independently of engine and art direction. The [Classification](classification.md) remains the local taxonomy; the [Screen Hierarchy](screen-hierarchy.md) defines ownership roles.
-
-## Reusable Method
-
-1. Write the player's question while the interface is visible.
-2. Choose one primary task class from the table below.
-3. Decide whether play continues and which input actions must be blocked.
-4. Assign lifetime, focus, sorting, and state ownership.
-5. Adapt a [Screen Recipe](screen-recipes.md), then run the [Verification Workflow](verification-workflow.md).
-
-## Player Task Route
-
-| Player question | Primary class | Recipe |
-| --- | --- | --- |
-| What is happening during play? | `hud` | [Play status and input](screen-recipes.md#play-status-and-input) |
-| How do I perform an action? | `input-surface` | [Play status and input](screen-recipes.md#play-status-and-input) |
-| Where can I go, pause, or leave? | `navigation` | [Pause and navigation](screen-recipes.md#pause-and-navigation) |
-| What decision requires attention? | `dialog` | [Blocking decisions and connection](screen-recipes.md#blocking-decisions-and-connection) |
-| Is the game ready or connected? | `system-status` | [Blocking decisions and connection](screen-recipes.md#blocking-decisions-and-connection) |
-| What can I equip or compare? | `inventory` | [Inventory and comparison](screen-recipes.md#inventory-and-comparison) |
-| What have I earned or unlocked? | `progression` | [Results and progression](screen-recipes.md#results-and-progression) |
-| What can I obtain, and at what cost? | `commerce` | [Offers and acquisition](screen-recipes.md#offers-and-acquisition) |
-| What should I learn next? | `tutorial` | [Teaching and narrative](screen-recipes.md#teaching-and-narrative) |
-| What story is being presented? | `narrative` | [Teaching and narrative](screen-recipes.md#teaching-and-narrative) |
-
-If a screen contains several tasks, classify regions independently. A purchase confirmation inside an inventory screen is a dialog owned by a commerce operation; it is not another inventory slot.
-
-## Ownership Decisions
-
-| Decision | Record before implementing |
-| --- | --- |
-| Lifetime | Application, session, scene, screen, entity, or one operation |
-| Play relationship | Continues, pauses locally, or requests a networked pause; identify authority |
-| Input | Active action map, focus owner, pointer/gamepad coexistence, cancellation |
-| Ordering | Screen, HUD, world-linked, modal, or transient host; name competing hosts |
-| Data | Authoritative state versus preview, selection, pending operation and stale data |
-| Exit | What is restored, destroyed, retained, or reconciled |
-
-## Worked Selection
-
-A loadout screen shows owned equipment, character attributes, and a purchase button for an unavailable slot. Inventory is primary; comparison is a supporting region. The purchase flow is commerce and any confirmation is a modal decision. Closing the modal returns to the same slot. Losing connection updates operation status without clearing the loadout selection. A server response after the screen closes belongs to the operation owner, not a destroyed view.
-
-## Opinionated Guidance
-
-Separate the player's task from visual genre. Assign one cancellation owner for each active layer so the same Back/Cancel input does not dismiss a dialog and its parent screen together.
-
-## Platform-Specific Guidance
-
-For Unity, select the [UI System](unity/ui-systems.md), map [Architecture](unity/architecture.md), then use the [CLI Loop](unity/cli-loop.md) for the declared stack. Other engines retain these role contracts but require their own verified API mapping; no cross-engine runtime equivalence is claimed.
-
-## Unsupported Absolutes
-
-A pause menu does not imply multiplayer simulation can pause. Hierarchy order does not prove input blocking, focus, or sorting. A taxonomy label does not establish rendered behavior.
-
-## Verification Contract
-
-Check one ordinary screen, one overlay composition, and one unexpected interruption such as disconnection or scene teardown. Every active layer needs a named lifetime, input, sorting, and exit owner. Revisit the route if a real player task cannot be classified without forcing unrelated responsibilities together.
-
-## Source, License, And Attribution
-
-Locally authored route and fictional loadout case. It imports no game assets, third-party hierarchy, or engine code.
-
-## IA Navigation
-
-Parent: [Game UI](index.md).
-Next: [Game UI Screen Recipes](screen-recipes.md).

package/game-ui/index.md

@@ -1,45 +0,0 @@
-# Game UI
-
-Game UI owns engine-neutral guidance for game-interface purpose, presentation, screen hierarchy, and evidence records, plus named engine implementation guides.
-
-## Scope Boundary
-
-In scope: player-task classification, screen and overlay hierarchy, reusable reference metadata, state coverage, cross-engine comparison vocabulary, and engine-specific implementation guidance.
-
-Out of scope: reusable Layout CSS, universal visual prescriptions, and treating one engine's scene graph or API as a cross-engine requirement.
-
-## Evidence And Research Boundary
-
-The player-task classes and classification axes are a local taxonomy proposed for StyleGallery review, not Interface In Game's universal ontology.
-
-Interface In Game was reviewed on 2026-07-14 through its [home page](https://interfaceingame.com/), [games index](https://interfaceingame.com/games/), and representative records for [Team Fortress 2](https://interfaceingame.com/games/team-fortress-2/), [Genshin Impact (Mobile)](https://interfaceingame.com/games/genshin-impact-mobile/), and [Gris](https://interfaceingame.com/games/gris/). In this bounded sample, the site exposed site-local facets such as Genres, Themes, and Platforms, while screenshots used Elements. The sample informs the local separation of player task from other axes; it does not cover the archive or establish the site's full information model.
-
-## Start Here
-
-| Task | Route |
-| --- | --- |
-| Choose by player task and ownership. | [Game UI Decision Tree](decision-tree.md) |
-| Compose all ten player-task classes with failure cases. | [Game UI Screen Recipes](screen-recipes.md) |
-| Record input, state, hierarchy, and teardown evidence. | [Game UI Verification Workflow](verification-workflow.md) |
-
-These workflows and worked cases are usable experimental guidance. Expected-result tables are test designs; actual product, engine, and reader evidence must be recorded separately. Review on a failed task, a source change, or a changed ownership contract.
-
-## Available Guides
-
-- [Game UI Classification](classification.md) separates player purpose from visual language, input, state, and motion.
-- [Game UI Screen Hierarchy](screen-hierarchy.md) defines engine-neutral layers from application shell to atomic control.
-- [Game UI Reference Record](reference-record.md) provides the minimum evidence schema for gallery entries.
-- [Unity UI Architecture](unity/architecture.md) maps the hierarchy roles to Unity Scenes, Canvas layers, prefabs, runtime instances, input, and motion ownership.
-- [Unity UI Systems](unity/ui-systems.md) compares uGUI, UI Toolkit, and NGUI ownership and capability shapes at pinned sources.
-- [Unity CLI Loop](unity/cli-loop.md) defines a source-pinned command loop for Unity UI inspection and stack-specific interaction evidence.
-- [Unity Repository Map](unity/repository-map.md) maps the public Unity-Technologies repository snapshot by UI relevance, authority, and lifecycle.
-- [Unity Organization Compressed Wiki](unity/org-wiki.md) routes all 804 captured public repositories through a tracked inventory and bounded exclusive clusters.
-
-## Domain Contract
-
-Game UI describes interface purpose, screen composition, and how named engines can realize that model. Platform Guides cover non-game platform conventions; Layout owns portable spatial patterns.
-
-## IA Navigation
-
-Parent: [StyleGallery](../index.md).
-Next: [Game UI Decision Tree](decision-tree.md).