@xenosystem/blocks 0.1.0

package/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) XENO Corporation. All rights reserved.
+
+This software is proprietary and confidential. It is UNLICENSED: no licence,
+express or implied, is granted to any person to use, copy, modify, merge,
+publish, distribute, sublicense, or sell copies of this software, except under a
+separate written agreement with XENO Corporation.
+
+This file restates the `"license": "UNLICENSED"` declaration already present in
+every package manifest. It exists so that the declaration travels inside the
+published tarball, where package.json alone is easy to miss.

package/dist/auth/index.d.ts

@@ -0,0 +1,121 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { PanelModule, PanelManifest } from '@xenosystem/panel-sdk';
+import { XenoAccountStatus, XenoAccountIdentity, XenoAccountActionKind } from '@xenosystem/panel-account';
+export * from '@xenosystem/panel-account';
+
+interface CreateAuthGatePanelOptions {
+    /** What renders behind the gate once it is `open`. A product passes its app; the harness a fixture. */
+    children?: () => ReactNode;
+    heroSrc?: string;
+    now?: () => number;
+}
+declare function createAuthGatePanel(options?: CreateAuthGatePanelOptions): PanelModule;
+declare const authGatePanel: PanelModule;
+
+declare const AUTH_GATE_PANEL_ID = "xeno.core.auth-gate";
+/**
+ * The gate's manifest. It declares ONE input (the two axes) and ONE output (an intent), no
+ * commands: an agent-invocable "sign in" is by definition not interactive (AUTH L8), and a gate
+ * an agent can open is not a gate.
+ */
+declare const authGateManifest: PanelManifest;
+
+/**
+ * `xeno.core.auth-gate` — the door in front of a XENO product.
+ *
+ * Contract: `XENO AUTH - AUTH GATE DELTA.md` §2–§3. Two host-pushed AXES, one derived PHASE.
+ *
+ * 🔴 The gate never derives a FACT. Whether the person is signed in and whether the build is
+ * licensed are decided in the product's main process (AUTH L9, §12.3; LICENCE-ENFORCEMENT §1
+ * "main process, never the renderer"). What is derived here is only which plate to show for the
+ * facts the host reported.
+ */
+
+/** LICENCE-ENFORCEMENT §3 — the four states every product must handle honestly. */
+type XenoLicenceState = 'licensed' | 'unlicensed' | 'expired-offline' | 'update-required';
+/** What the host pushes on the `auth` input. Contains NO token, by construction (AUTH L9). */
+interface XenoAuthGateState {
+    /** The account axis — `panel-account`'s vocabulary, not a second one. */
+    account: XenoAccountStatus;
+    /** The licence axis; `checking` while the main-process check has not answered yet. */
+    licence: XenoLicenceState | 'checking';
+    /**
+     * Whether the host CAN sign someone in at all: `unavailable` when the OS keystore is unusable
+     * (AUTH L9 hard-fail) or no account authority is composed. A sign-in button that cannot work
+     * is worse than none — the gate says why instead.
+     */
+    sdk: 'ready' | 'unavailable';
+    /** An interactive sign-in is in flight (the browser is open). Keeps the `sign-in` plate, disables its button. */
+    pending?: boolean;
+    /** Who is signed in, when known. Display only. */
+    identity?: XenoAccountIdentity;
+    /** The host's own sentence for the current state — the reason a keystore is unusable, the plan that is missing, the floor a build is below. */
+    message?: string;
+    /** For `expired-offline`: when the licence was last confirmed, so the plate can say how long ago. */
+    lastVerifiedAt?: number;
+    /** Which intents the host implements. A missing one hides its affordance (COMPONENTS §1.7). */
+    capabilities?: Partial<Record<XenoAuthGateIntentKind, boolean>>;
+}
+/** What the gate shows. Exactly one at a time; `open` renders nothing of the gate at all. */
+type XenoAuthGatePhase = 'unavailable' | 'checking' | 'sign-in' | 'update-required' | 'expired-offline' | 'unlicensed' | 'open';
+/**
+ * DELTA §2, in order — first match wins. Pure, so a host can be tested against it without a DOM.
+ */
+declare function deriveAuthGatePhase(state: XenoAuthGateState): XenoAuthGatePhase;
+/**
+ * DELTA §2, last paragraph: "fail OPEN on a network error, CLOSED on an explicit refusal" is the
+ * HOST's rule, but the gate can see one combination the rule forbids — an account the host could
+ * not reach (`offline`) reported alongside an explicit `unlicensed`. Nobody refused anyone; the
+ * network did. The gate shows the honest plate and names the contradiction.
+ */
+declare function hostContradiction(state: XenoAuthGateState): string | null;
+/** The only way out of the gate. `panel-account`'s intents plus the two a door needs (DELTA §3). */
+type XenoAuthGateIntentKind = Extract<XenoAccountActionKind, 'signIn' | 'signOut' | 'refresh' | 'manageBilling'> | 'cancelSignIn' | 'openDownload';
+interface XenoAuthGateIntent {
+    kind: XenoAuthGateIntentKind;
+}
+/** Which intents each phase may offer. The view never offers one outside this table. */
+declare const PHASE_INTENTS: Readonly<Record<XenoAuthGatePhase, readonly XenoAuthGateIntentKind[]>>;
+declare function intentOffered(state: XenoAuthGateState, kind: XenoAuthGateIntentKind): boolean;
+/** The initial state before the host has said anything. */
+declare const AUTH_GATE_INITIAL: XenoAuthGateState;
+declare function formatSince(lastVerifiedAt: number | undefined, now: number): string | null;
+
+interface AuthGateHostBridge {
+    emit: (portId: 'intent', value: XenoAuthGateIntent) => void;
+    /** Where a host contradiction is reported. Default: console.warn. */
+    warn?: (message: string) => void;
+}
+/**
+ * Holds the last pushed state and derives the phase. Deliberately tiny: a controller that
+ * remembered more than the host said would be a place for a fact to be invented.
+ */
+declare class AuthGateController {
+    private readonly host;
+    private state;
+    private readonly listeners;
+    private lastWarned;
+    constructor(host: AuthGateHostBridge);
+    setState(next: XenoAuthGateState): void;
+    getState(): XenoAuthGateState;
+    getPhase(): XenoAuthGatePhase;
+    offers(kind: XenoAuthGateIntentKind): boolean;
+    /** Emit an intent — only if this phase offers it. A hidden button cannot be pressed by code either. */
+    intend(kind: XenoAuthGateIntentKind): boolean;
+    subscribe(listener: () => void): () => void;
+    dispose(): void;
+}
+
+interface AuthGateViewProps {
+    controller: AuthGateController;
+    productName: string;
+    /** Rendered ONLY when the phase is `open`. */
+    children?: ReactNode;
+    /** Optional hero image (Hub's login art). */
+    heroSrc?: string;
+    now?: () => number;
+}
+declare function AuthGateView({ controller, productName, children, heroSrc, now }: AuthGateViewProps): react.JSX.Element;
+
+export { AUTH_GATE_INITIAL, AUTH_GATE_PANEL_ID, AuthGateController, type AuthGateHostBridge, AuthGateView, type AuthGateViewProps, type CreateAuthGatePanelOptions, PHASE_INTENTS, type XenoAuthGateIntent, type XenoAuthGateIntentKind, type XenoAuthGatePhase, type XenoAuthGateState, type XenoLicenceState, authGateManifest, authGatePanel, createAuthGatePanel, deriveAuthGatePhase, formatSince, hostContradiction, intentOffered };

package/dist/auth/index.js

@@ -0,0 +1,274 @@
+// src/auth/gate/panel.ts
+import { createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { bindConfig } from "@xenosystem/panel-sdk";
+
+// src/auth/gate/types.ts
+function deriveAuthGatePhase(state) {
+  if (state.sdk === "unavailable") return "unavailable";
+  if (state.account === "unknown") return "checking";
+  if (state.account === "signedOut" || state.account === "expired") return "sign-in";
+  if (state.licence === "checking") return "checking";
+  if (state.licence === "update-required") return "update-required";
+  if (state.licence === "expired-offline") return "expired-offline";
+  if (state.licence === "unlicensed") return "unlicensed";
+  return "open";
+}
+function hostContradiction(state) {
+  if (state.account === "offline" && state.licence === "unlicensed") {
+    return "host reported unlicensed while offline \u2014 a network error is not a refusal (LICENCE-ENFORCEMENT \xA74)";
+  }
+  return null;
+}
+var PHASE_INTENTS = {
+  unavailable: ["refresh"],
+  checking: [],
+  "sign-in": ["signIn", "cancelSignIn"],
+  "update-required": ["openDownload", "signOut"],
+  "expired-offline": ["refresh", "signOut"],
+  unlicensed: ["manageBilling", "refresh", "signOut"],
+  open: []
+};
+function intentOffered(state, kind) {
+  const phase = deriveAuthGatePhase(state);
+  if (!PHASE_INTENTS[phase].includes(kind)) return false;
+  if (kind === "cancelSignIn") return state.pending === true;
+  if (kind === "signIn") return state.pending !== true;
+  if (state.capabilities && state.capabilities[kind] === false) return false;
+  return true;
+}
+var AUTH_GATE_INITIAL = { account: "unknown", licence: "checking", sdk: "ready" };
+function formatSince(lastVerifiedAt, now) {
+  if (!lastVerifiedAt) return null;
+  const days = Math.floor(Math.max(0, now - lastVerifiedAt) / 864e5);
+  if (days <= 0) return "today";
+  if (days === 1) return "yesterday";
+  return `${days} days ago`;
+}
+
+// src/auth/gate/controller.ts
+var AuthGateController = class {
+  constructor(host) {
+    this.host = host;
+  }
+  host;
+  state = AUTH_GATE_INITIAL;
+  listeners = /* @__PURE__ */ new Set();
+  lastWarned = null;
+  setState(next) {
+    this.state = next;
+    const contradiction = hostContradiction(next);
+    if (contradiction && contradiction !== this.lastWarned) {
+      ;
+      (this.host.warn ?? ((m) => console.warn(`[xeno.core.auth-gate] ${m}`)))(contradiction);
+      this.lastWarned = contradiction;
+    }
+    for (const l of this.listeners) l();
+  }
+  getState() {
+    return this.state;
+  }
+  getPhase() {
+    return deriveAuthGatePhase(this.state);
+  }
+  offers(kind) {
+    return intentOffered(this.state, kind);
+  }
+  /** Emit an intent — only if this phase offers it. A hidden button cannot be pressed by code either. */
+  intend(kind) {
+    if (!this.offers(kind)) return false;
+    this.host.emit("intent", { kind });
+    return true;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  dispose() {
+    this.listeners.clear();
+  }
+};
+
+// src/auth/gate/manifest.ts
+var AUTH_GATE_PANEL_ID = "xeno.core.auth-gate";
+var authGateManifest = {
+  id: AUTH_GATE_PANEL_ID,
+  version: "0.1.0",
+  title: "Auth Gate",
+  icon: "lock",
+  description: "The door in front of a XENO product. Shows sign-in (system browser only) and the four licence states from host-pushed facts; renders the product only when signed in AND licensed. Holds no token, calls no SDK.",
+  defaultSlot: "center",
+  inputs: [
+    {
+      id: "auth",
+      name: "Auth",
+      type: "object",
+      description: "{account, licence, sdk, pending?, identity?, message?, lastVerifiedAt?, capabilities?}. Two facts the host decided in its main process. Contains NO token \u2014 AUTH L9.",
+      multiple: false
+    }
+  ],
+  outputs: [
+    {
+      id: "intent",
+      name: "Intent",
+      type: "object",
+      description: "{kind}: signIn | cancelSignIn | signOut | refresh | manageBilling | openDownload. An INTENT the host performs; the gate changes nothing itself."
+    }
+  ],
+  commands: [],
+  config: [
+    { key: "productName", label: "Product name", type: "text", defaultValue: "XENO", description: 'Named in the copy: "Sign in to use XENO Canvas."' },
+    { key: "productSlug", label: "Product slug", type: "text", defaultValue: "", description: "The platform slug; reported back on intents so the host can open the right download / plan page." }
+  ],
+  capabilities: [],
+  sdk: "^1.1.0"
+};
+
+// src/auth/gate/react/AuthGateView.tsx
+import { useEffect, useState } from "react";
+import { AuthDoor, SignInForm } from "@xenosystem/components/auth";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function AuthGateView({ controller, productName, children, heroSrc, now = () => Date.now() }) {
+  const [, force] = useState(0);
+  useEffect(() => controller.subscribe(() => force((n) => n + 1)), [controller]);
+  const phase = controller.getPhase();
+  if (phase === "open") return /* @__PURE__ */ jsx(Fragment, { children });
+  const state = controller.getState();
+  const copy = plateCopy(phase, productName, state.message, formatSince(state.lastVerifiedAt, now()));
+  const action = (id, label, variant = "primary") => controller.offers(id) ? [{ id, label, variant, onClick: () => controller.intend(id) }] : [];
+  const actions = [
+    ...phase === "sign-in" && state.pending ? [{ id: "pending", label: "Finish in your browser\u2026", variant: "primary", disabled: true }] : [],
+    ...action("signIn", "Sign in to XENO"),
+    ...action("cancelSignIn", "Cancel", "quiet"),
+    ...action("openDownload", `Download the latest ${productName}`),
+    ...action("manageBilling", "Choose a plan"),
+    ...action("refresh", phase === "unlicensed" || phase === "expired-offline" ? "Check again" : "Try again", phase === "unlicensed" ? "quiet" : "primary"),
+    ...action("signOut", "Sign out", "quiet")
+  ];
+  const identity = state.identity && phase !== "sign-in" ? state.identity.email ?? state.identity.name ?? state.identity.sub : void 0;
+  return /* @__PURE__ */ jsx(
+    AuthDoor,
+    {
+      label: `${productName} sign-in`,
+      rootAttributes: { "data-xeno-auth-gate": phase },
+      hero: {
+        imageSrc: heroSrc,
+        headline: /* @__PURE__ */ jsxs(Fragment, { children: [
+          "One account.",
+          /* @__PURE__ */ jsx("br", {}),
+          "Every XENO product."
+        ] }),
+        lead: `Sign in once and ${productName} \u2014 and every other XENO app \u2014 runs under your plan, your credits and your files.`,
+        stats: [
+          { value: "1", label: "Account" },
+          { value: "Yours", label: "Files stay put" },
+          { value: "Browser", label: "Sign-in, never in-app" }
+        ]
+      },
+      children: /* @__PURE__ */ jsx(
+        SignInForm,
+        {
+          phase,
+          tag: copy.tag,
+          title: copy.title,
+          body: copy.body,
+          actions,
+          note: phase === "sign-in" && !state.pending ? `Your browser opens at xenostudio.ai, where you can continue with Google, GitHub or email. ${productName} never sees your password.` : void 0,
+          warning: copy.note,
+          identity
+        }
+      )
+    }
+  );
+}
+function plateCopy(phase, product, message, since) {
+  switch (phase) {
+    case "checking":
+      return { title: "One moment", body: `Checking your XENO account\u2026` };
+    case "sign-in":
+      return { title: "Welcome back", body: message ?? `Sign in to your XENO account to use ${product}.` };
+    case "unavailable":
+      return { tag: "Sign-in unavailable", title: "Can\u2019t reach your account", body: message ?? `${product} cannot store a sign-in on this machine right now.` };
+    case "update-required":
+      return { tag: "Update required", title: `Update ${product} to continue`, body: message ?? `This version of ${product} is older than the oldest one still supported. The latest version is a short download away.` };
+    case "expired-offline":
+      return { tag: "Offline too long", title: "Your plan couldn\u2019t be confirmed", body: `${product} hasn\u2019t been able to reach XENO for 14 days${since ? ` \u2014 last confirmed ${since}` : ""}. Your plan may be fine; connect once and it will pick up where it left off.`, note: message };
+    case "unlicensed":
+      return { tag: "No active plan", title: `${product} needs a plan`, body: message ?? `Your XENO account doesn\u2019t include ${product} yet. Choose a plan to use it \u2014 nothing on this machine changes until you do.` };
+    default:
+      return { title: "", body: "" };
+  }
+}
+
+// src/auth/gate/panel.ts
+function createAuthGatePanel(options = {}) {
+  return {
+    manifest: authGateManifest,
+    activate(host) {
+      const controller = new AuthGateController({ emit: (port, value) => host.emit(port, value) });
+      const resolve = (config) => ({
+        productName: typeof config.productName === "string" && config.productName ? config.productName : "XENO"
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let root = null;
+      let el = null;
+      const draw = () => {
+        if (!el) return;
+        el.style.position = el.style.position || "relative";
+        root ??= createRoot(el);
+        root.render(
+          createElement(AuthGateView, {
+            controller,
+            productName: renderConfig.productName,
+            heroSrc: options.heroSrc,
+            now: options.now,
+            children: options.children?.()
+          })
+        );
+      };
+      const unbindConfig = bindConfig(host, (config) => {
+        renderConfig = resolve(config);
+        draw();
+      });
+      return {
+        render(target) {
+          el = target;
+          draw();
+        },
+        onInput(portId, value) {
+          if (portId === "auth" && value && typeof value === "object" && "account" in value && "licence" in value && "sdk" in value) {
+            controller.setState(value);
+          }
+        },
+        async onCommand() {
+          return;
+        },
+        dispose() {
+          unbindConfig();
+          root?.unmount();
+          root = null;
+          el = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var authGatePanel = createAuthGatePanel();
+
+// src/auth/index.ts
+export * from "@xenosystem/panel-account";
+export {
+  AUTH_GATE_INITIAL,
+  AUTH_GATE_PANEL_ID,
+  AuthGateController,
+  AuthGateView,
+  PHASE_INTENTS,
+  authGateManifest,
+  authGatePanel,
+  createAuthGatePanel,
+  deriveAuthGatePhase,
+  formatSince,
+  hostContradiction,
+  intentOffered
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@xenosystem/blocks` — rung 3 of the FRONT ladder — BLOCKS (`XENO FRONT-END HIERARCHY.md`).
+ * Families are subpaths: `@xenosystem/blocks/auth`, `/edit`, `/data`, `/time`, `/ops`, `/trust`,
+ * `/agent`. This root re-exports nothing on purpose: import the family you mount, so a product
+ * carries only it. Naming rule: `XENO PACKAGE NAMING - STANDARD.md`.
+ */
+declare const BLOCKS_VERSION = "0.1.0";
+
+export { BLOCKS_VERSION };

package/dist/index.js

@@ -0,0 +1,5 @@
+// src/index.ts
+var BLOCKS_VERSION = "0.1.0";
+export {
+  BLOCKS_VERSION
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@xenosystem/blocks",
+  "version": "0.1.0",
+  "description": "XENO Blocks — rung 3 of the front ladder: components composed into a contract-bearing unit (manifest: ports, intents, commands, agent surface), rendered by @xenosystem/workbench. ONE package, one subpath per family (/auth, /edit, /data, /time, /ops, /trust, /agent), one named export per block — XENO PACKAGE NAMING - STANDARD.md.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./auth": {
+      "types": "./dist/auth/index.d.ts",
+      "import": "./dist/auth/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@xenosystem/components": "^0.1.0",
+    "@xenosystem/elements-react": ">=0.0.1",
+    "@xenosystem/panel-account": "^0.1.0",
+    "@xenosystem/panel-sdk": "^1.1.0",
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@xenosystem/components": "^0.1.0",
+    "@xenosystem/elements-react": "0.0.1",
+    "@xenosystem/panel-account": "^0.1.0",
+    "@xenosystem/panel-sdk": "^1.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}