@dupliter/dupliter 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ashlan Chidester
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @dupliter/dupliter 🪐
+
+**Retro BBS-style terminal simulator for the Dupliter gravitational-temporal anchor hypothesis.**
+
+Computes the relativistic/classical kinetic-energy ratio and a pedagogical *Dupliter Stability Index* (DSI).
+
+```
+   ____  _   _  _     _ _ _  _   _  ___  _   _  _____
+  |  _ \| | | || |   (_) | \| | | |/ _ \| \ | ||_   _|
+  | | | | |_| || |    _| | .` | | | | | |  \| |  | |
+  | |_| |  _  || |___| | | |\  |_| | |_| | |\  |  | |
+  |____/|_| |_||_____|_|_|_| \_(_) |\___/|_| \_|  |_|
+```
+
+Also available on PyPI: [`pip install dupliter`](https://pypi.org/project/dupliter/)
+
+## Install
+
+```bash
+npm install -g @dupliter/dupliter
+```
+
+## Run
+
+```bash
+dupliter
+```
+
+Or without installing globally:
+
+```bash
+npx @dupliter/dupliter
+```
+
+## JS API
+
+```js
+import { relativisticToClassicalRatio, dupliterStabilityIndex, verdict } from '@dupliter/dupliter';
+
+const ratio = relativisticToClassicalRatio(0.5);   // β = 0.5c
+const dsi   = dupliterStabilityIndex(ratio, 2.0, 3.0);
+const { level, message } = verdict(dsi);
+
+console.log(`Ratio : ${ratio.toFixed(4)}`);
+console.log(`DSI   : ${dsi.toFixed(2)}  [${level}] — ${message}`);
+```
+
+## Parameters
+
+| Parameter | Description |
+|---|---|
+| **β (v/c)** | Fractional velocity as a fraction of light speed (0 – 0.9999) |
+| **Dark-matter potential** | Dimensionless toy factor representing local DM density |
+| **Anchor strength** | Dimensionless toy factor for gravitational anchor magnitude |
+
+## Equation
+
+```
+ratio = 2 * (1/√(1−β²) − 1) / β²
+```
+
+| DSI range | Verdict |
+|---|---|
+| ≥ 60 | High — plausible Dupliter regime |
+| 30–59 | Moderate — marginal potential |
+| 1–29 | Low — unstable |
+| 0 | None |
+
+> **Note:** DSI is an exploratory, educational metric — not a peer-reviewed physical quantity.
+
+## License
+
+MIT © Ashlan Chidester

package/bin/dupliter.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * dupliter CLI — launches the BBS terminal.
+ * Installed as `dupliter` command via package.json bin field.
+ */
+
+import { main } from '../src/bbs.js';
+
+main().catch((err) => {
+  if (err.code === 'ERR_USE_AFTER_CLOSE') process.exit(0); // readline closed cleanly
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,8 +1,40 @@
 {
   "name": "@dupliter/dupliter",
-  "version": "0.0.1",
-  "description": "Conceptual placeholder for Dupliter",
-  "main": "index.js",
+  "version": "0.1.0",
+  "description": "Retro BBS-style terminal simulator for the Dupliter gravitational-temporal anchor hypothesis",
   "author": "Ashlan Chidester",
-  "license": "MIT"
+  "license": "MIT",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./core": "./src/core.js"
+  },
+  "bin": {
+    "dupliter": "./bin/dupliter.js"
+  },
+  "keywords": [
+    "physics",
+    "relativity",
+    "terminal",
+    "bbs",
+    "simulation",
+    "educational",
+    "dupliter",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dupliter/dupliter"
+  },
+  "homepage": "https://www.npmjs.com/package/@dupliter/dupliter",
+  "files": [
+    "src/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/src/bbs.js

@@ -0,0 +1,164 @@
+/**
+ * dupliter/bbs.js
+ * Retro BBS-style terminal front-end for the Dupliter hypothesis simulator.
+ */
+
+import * as readline from 'readline';
+import { relativisticToClassicalRatio, dupliterStabilityIndex, verdict } from './core.js';
+
+// ---------------------------------------------------------------------------
+// ANSI helpers
+// ---------------------------------------------------------------------------
+const CSI   = '\x1b[';
+const RESET = CSI + '0m';
+const BOLD  = CSI + '1m';
+const fg    = (n) => `${CSI}38;5;${n}m`;
+
+function clear() { process.stdout.write(CSI + '2J' + CSI + 'H'); }
+
+function slowPrint(text, delay = 6) {
+  return new Promise((resolve) => {
+    let i = 0;
+    const tick = () => {
+      if (i < text.length) {
+        process.stdout.write(text[i++]);
+        setTimeout(tick, delay);
+      } else {
+        process.stdout.write('\n');
+        resolve();
+      }
+    };
+    tick();
+  });
+}
+
+function divider() {
+  const cols = process.stdout.columns || 80;
+  console.log(fg(238) + '─'.repeat(cols) + RESET);
+}
+
+function headline(text) {
+  const cols = process.stdout.columns || 80;
+  const pad  = Math.max(0, Math.floor((cols - text.length) / 2));
+  console.log(fg(81) + BOLD + ' '.repeat(pad) + text + RESET);
+}
+
+// ---------------------------------------------------------------------------
+// Art & copy
+// ---------------------------------------------------------------------------
+const JUPITER = `
+                 .-''-.
+              .-'  .---.  \`-.
+             /   .'     \`.   \\
+            /   /  .-"-.-. \\   \\
+           ;   ;  /  .-.  \\;    ;
+           |   | |  /   \\  ||   |
+           ;   ; | | .-. | ;'   ;
+            \\   \\ \\ \`-' / /   /
+             \`.  \`.\`\`\`.'  .' .'
+               \`-._\`---'_.-'
+                    \`---'
+`;
+
+const BANNER = [
+  `${fg(220)}${BOLD}   ____  _   _  _     _ _ _  _   _  ___  _   _  _____ ${RESET}`,
+  `${fg(220)}${BOLD}  |  _ \\| | | || |   (_) | \\| | | |/ _ \\| \\ | ||_   _|${RESET}`,
+  `${fg(220)}${BOLD}  | | | | |_| || |    _| | .\` | | | | | |  \\| |  | |  ${RESET}`,
+  `${fg(220)}${BOLD}  | |_| |  _  || |___| | | |\\  |_| | |_| | |\\  |  | |  ${RESET}`,
+  `${fg(220)}${BOLD}  |____/|_| |_||_____|_|_|_| \\_(_) |\\___/|_| \\_|  |_|  ${RESET}`,
+];
+
+const INTRO =
+  'Connecting to DUPliter Node... BBS handshake engaged.\n' +
+  'Transmitting the Dupliter hypothesis — a gravitational temporal anchor.\n' +
+  'This simulator computes the relativistic/classical KE ratio and a\n' +
+  'pedagogical Dupliter Stability Index (DSI).\n\n' +
+  'Note: DSI is a comparative, educational metric. Play, learn,\n' +
+  'and refine models responsibly.\n';
+
+const VERDICT_COLOURS = {
+  High:     (m) => fg(82)  + BOLD + m + RESET,
+  Moderate: (m) => fg(226) + m + RESET,
+  Low:      (m) => fg(208) + m + RESET,
+  None:     (m) => fg(196) + m + RESET,
+};
+
+// ---------------------------------------------------------------------------
+// Input helpers
+// ---------------------------------------------------------------------------
+function promptFloat(rl, question, defaultVal, minVal, maxVal) {
+  return new Promise((resolve) => {
+    const ask = () => {
+      rl.question(fg(250) + question + RESET + ' ', (raw) => {
+        const trimmed = raw.trim();
+        if (trimmed === '') { resolve(defaultVal); return; }
+        const val = parseFloat(trimmed);
+        if (isNaN(val)) {
+          console.log(fg(208) + 'Please enter a valid number.' + RESET);
+          ask(); return;
+        }
+        if (minVal !== undefined && val < minVal) {
+          console.log(fg(196) + `Value too small (minimum ${minVal}).` + RESET);
+          ask(); return;
+        }
+        if (maxVal !== undefined && val > maxVal) {
+          console.log(fg(196) + `Value too large (maximum ${maxVal}).` + RESET);
+          ask(); return;
+        }
+        resolve(val);
+      });
+    };
+    ask();
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+export async function main() {
+  clear();
+  BANNER.forEach((l) => console.log(l));
+  console.log(fg(244) + JUPITER + RESET);
+  await slowPrint(INTRO, 4);
+  headline('DUPliter INTERACTIVE TERMINAL  v0.1.0');
+  console.log();
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const loop = async () => {
+    console.log(fg(153) + BOLD + 'Enter parameters (press Enter to accept defaults):' + RESET);
+
+    const beta   = await promptFloat(rl, 'Fractional velocity β = v/c, range 0..0.9999 [default 0.1]:', 0.1, 0, 0.9999);
+    const dm     = await promptFloat(rl, 'Dark-matter potential factor (0..1000000) [default 1.0]:', 1.0, 0, 1e6);
+    const anchor = await promptFloat(rl, 'Gravitational anchor strength (0..1000000) [default 1.0]:', 1.0, 0, 1e6);
+    console.log();
+
+    const ratio  = relativisticToClassicalRatio(beta);
+    const dsi    = dupliterStabilityIndex(ratio, dm, anchor);
+    const { level, message } = verdict(dsi);
+    const coloured = (VERDICT_COLOURS[level] || ((m) => m))(message);
+
+    divider();
+    console.log(fg(39) + BOLD + 'Computed metrics:' + RESET);
+    console.log(`  β (v/c)                          : ${fg(153)}${beta.toPrecision(6)}${RESET}`);
+    console.log(`  Relativistic / Classical KE ratio: ${fg(153)}${ratio.toPrecision(6)}${RESET}`);
+    console.log(`  Dupliter Stability Index (DSI)   : ${fg(153)}${dsi.toFixed(4)}${RESET}  [${level}]`);
+    console.log(`  Assessment                       : ${coloured}`);
+    console.log();
+    console.log(fg(244) + '  Equation: 2*(1/√(1−β²) − 1) / β²   where β = v/c' + RESET);
+    divider();
+    console.log();
+
+    rl.question(fg(250) + 'Run another simulation? (Y/n): ' + RESET, async (ans) => {
+      if (ans.trim().toLowerCase() === 'n' || ans.trim().toLowerCase() === 'no') {
+        console.log(fg(245) + 'Disconnecting from DUPliter Node. Keep hypothesizing.' + RESET);
+        rl.close();
+      } else {
+        console.log();
+        await loop();
+      }
+    });
+  };
+
+  await loop();
+}

package/src/core.js

@@ -0,0 +1,60 @@
+/**
+ * dupliter/core.js
+ * Pure-math functions for the Dupliter hypothesis simulator.
+ * No I/O or terminal dependencies — safe to import anywhere.
+ */
+
+/**
+ * Compute the ratio of relativistic KE to classical KE.
+ *
+ * Formula:  2 * (1/√(1−β²) − 1) / β²
+ * where β = v/c (fraction of light speed).
+ *
+ * @param {number} beta - v/c, must be in range [0, 1)
+ * @returns {number} ratio (Infinity if beta >= 1, 0 if beta <= 0)
+ */
+export function relativisticToClassicalRatio(beta) {
+  if (beta <= 0) return 0;
+  if (beta >= 1) return Infinity;
+  const gamma = 1 / Math.sqrt(1 - beta * beta);
+  return (2 * (gamma - 1)) / (beta * beta);
+}
+
+/**
+ * Heuristic Dupliter Stability Index (DSI).
+ *
+ * Combines the relativistic/classical KE ratio with toy environmental
+ * parameters into a 0–100-ish comparative score.
+ *
+ * Educational/exploratory metric — not a peer-reviewed physical quantity.
+ *
+ * @param {number} ratio         - output of relativisticToClassicalRatio()
+ * @param {number} dmFactor      - dark-matter potential (dimensionless)
+ * @param {number} anchorStrength - gravitational anchor strength (dimensionless)
+ * @param {number} [noise=0.01]  - random noise fraction
+ * @returns {number} DSI score >= 0
+ */
+export function dupliterStabilityIndex(ratio, dmFactor, anchorStrength, noise = 0.01) {
+  const r = Math.max(ratio, 1e-12);
+  const logR = Math.log10(r + 1);
+  const base =
+    logR * 0.6 +
+    Math.log10(dmFactor + 1) * 0.25 +
+    Math.log10(anchorStrength + 1) * 0.15;
+  let dsi = (base / Math.log10(1e6 + 1)) * 100;
+  dsi *= 1 + (Math.random() * 2 - 1) * noise;
+  return Math.max(dsi, 0);
+}
+
+/**
+ * Return a verdict for a given DSI score.
+ *
+ * @param {number} dsi
+ * @returns {{ level: string, message: string }}
+ */
+export function verdict(dsi) {
+  if (dsi >= 60) return { level: 'High',     message: 'Plausible Dupliter regime — strong anchor.' };
+  if (dsi >= 30) return { level: 'Moderate', message: 'Marginal potential — further refinement needed.' };
+  if (dsi >  0)  return { level: 'Low',      message: 'Unstable — insufficient parameters.' };
+  return           { level: 'None',     message: 'No Dupliter potential detected.' };
+}

package/src/index.js

@@ -0,0 +1,7 @@
+/**
+ * @dupliter/dupliter
+ * Public API entry point.
+ */
+
+export { relativisticToClassicalRatio, dupliterStabilityIndex, verdict } from './core.js';
+export { main } from './bbs.js';

package/index.js

@@ -1,5 +0,0 @@
-// Dupliter: conceptual anchor
-module.exports = {
-  name: "dupliter",
-  description: "A conceptual placeholder for temporal anchoring theory"
-};