@twardoch/namzy 1.0.19 → 1.0.23

package/dist/cli.js

@@ -2,22 +2,20 @@
 // this_file: src/cli.ts
 import { generate } from "./index.js";
 const HELP = `
-namzy — generate fun fused project names
+namzy — generate compact, memorable, unique names
 
 Usage:
   namzy [options]
 
 Options:
   --count <N>     Number of names to generate (default: 1)
+  --seed <N>      Integer seed (default: current timestamp)
   --help          Show this help
-
-Examples:
-  namzy
-  namzy --count 5
 `.trimStart();
 function parseArgs(argv) {
     const args = argv.slice(2);
     let count = 1;
+    let seed;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         switch (arg) {
@@ -29,28 +27,33 @@ function parseArgs(argv) {
             case "--count": {
                 const n = parseInt(args[++i], 10);
                 if (Number.isNaN(n) || n < 1) {
-                    process.stderr.write(`--count must be a positive integer\n`);
+                    process.stderr.write("--count must be a positive integer\n");
                     process.exit(1);
                 }
                 count = n;
                 break;
             }
+            case "--seed": {
+                const n = parseInt(args[++i], 10);
+                if (Number.isNaN(n)) {
+                    process.stderr.write("--seed must be an integer\n");
+                    process.exit(1);
+                }
+                seed = n;
+                break;
+            }
             default:
                 process.stderr.write(`Unknown flag: ${arg}\nRun namzy --help for usage.\n`);
                 process.exit(1);
         }
     }
-    return { count };
+    return { count, seed };
 }
-async function main() {
-    const { count } = parseArgs(process.argv);
-    const base = Date.now();
+function main() {
+    const { count, seed } = parseArgs(process.argv);
+    const base = seed ?? Date.now();
     for (let i = 0; i < count; i++) {
-        const name = await generate({ seed: base + i * 1337 });
-        process.stdout.write(`${name}\n`);
+        process.stdout.write(`${generate({ seed: base + i * 2654435761 })}\n`);
     }
 }
-main().catch((err) => {
-    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
-    process.exit(1);
-});
+main();

package/dist/index.d.ts

@@ -1,11 +1,10 @@
-import { activeRotationMask, joinClean, mangle, mulberry32 } from "./mangle.js";
+import { applyRotation, buildName, mulberry32 } from "./mangle.js";
 export interface NamzyOptions {
     seed?: number;
 }
-/**
- * Generate a single fused, mangled namzy name.
- * Two raw words → junction-cleaned fusion → consonant rotation → capitalize.
- */
-export declare function generate(opts?: NamzyOptions): Promise<string>;
-export { COMMON, GEO } from "./wordlist.js";
-export { activeRotationMask, joinClean, mangle, mulberry32 };
+/** Generate one namzy name. Default seed is the current timestamp. */
+export declare function generate(opts?: NamzyOptions): string;
+/** Generate `count` names. Distinct seeds derived from the base seed. */
+export declare function generateMany(count: number, opts?: NamzyOptions): string[];
+export { STEMS, ROTATIONS } from "./wordlist.js";
+export { applyRotation, buildName, mulberry32 };

package/dist/index.js

@@ -1,24 +1,18 @@
 // this_file: src/index.ts
-import { activeRotationMask, joinClean, mangle, mulberry32 } from "./mangle.js";
-import { COMMON, GEO } from "./wordlist.js";
-function capitalize(s) {
-    return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function pick(arr, rng) {
-    return arr[Math.floor(rng() * arr.length)];
-}
-/**
- * Generate a single fused, mangled namzy name.
- * Two raw words → junction-cleaned fusion → consonant rotation → capitalize.
- */
-export async function generate(opts) {
+import { applyRotation, buildName, mulberry32 } from "./mangle.js";
+/** Generate one namzy name. Default seed is the current timestamp. */
+export function generate(opts) {
     const seed = opts?.seed ?? Date.now();
-    const rng = mulberry32(seed);
-    const w1 = pick(GEO, rng).toLowerCase();
-    const w2 = pick(COMMON, rng).toLowerCase();
-    const [first, second] = rng() < 0.5 ? [w1, w2] : [w2, w1];
-    const fused = joinClean(first, second);
-    return capitalize(mangle(fused, activeRotationMask(rng)));
+    return buildName(mulberry32(seed));
+}
+/** Generate `count` names. Distinct seeds derived from the base seed. */
+export function generateMany(count, opts) {
+    const base = opts?.seed ?? Date.now();
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        out.push(generate({ seed: base + i * 2654435761 }));
+    }
+    return out;
 }
-export { COMMON, GEO } from "./wordlist.js";
-export { activeRotationMask, joinClean, mangle, mulberry32 };
+export { STEMS, ROTATIONS } from "./wordlist.js";
+export { applyRotation, buildName, mulberry32 };

package/dist/mangle.d.ts

@@ -1,15 +1,5 @@
-/** Simple seeded mulberry32 RNG — returns a function that yields [0,1) floats */
 export declare function mulberry32(seed: number): () => number;
-type RotationRule = readonly [from: string, to: string];
-export declare const ROTATION_RULES: readonly RotationRule[];
-/** Choose 1..10 active consonant-rotation rules from the seeded RNG. */
-export declare function activeRotationMask(rng: () => number): number;
-/** Consonant rotation. Case-preserving. Defaults to all rules for direct helper use. */
-export declare function mangle(s: string, activeMask?: number): string;
-/**
- * Fuse two lowercase words at a clean junction.
- * Drops the first char of `b` while it duplicates the tail of `a`,
- * or while the seam is vowel-vowel. Max two trims.
- */
-export declare function joinClean(a: string, b: string): string;
-export {};
+/** Apply one rotation at a randomly chosen matching position. */
+export declare function applyRotation(s: string, rng: () => number): string;
+/** Build one name with junction validation + one rotation. */
+export declare function buildName(rng: () => number): string;

package/dist/mangle.js

@@ -1,85 +1,76 @@
 // this_file: src/mangle.ts
-/** Simple seeded mulberry32 RNG — returns a function that yields [0,1) floats */
+import { BAD_SEAMS, ROTATIONS, STEMS } from "./wordlist.js";
+const MAX_LEN = 12;
+const MAX_TRIES = 8;
 export function mulberry32(seed) {
     let s = seed >>> 0;
     return () => {
-        s += 0x6d2b79f5;
+        s = (s + 0x6d2b79f5) >>> 0;
         let t = Math.imul(s ^ (s >>> 15), 1 | s);
         t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
         return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
     };
 }
-export const ROTATION_RULES = [
-    ["c", "q"],
-    ["f", "v"],
-    ["k", "c"],
-    ["q", "k"],
-    ["s", "z"],
-    ["z", "s"],
-    ["v", "f"],
-    ["w", "u"],
-    ["b", "p"],
-    ["p", "b"],
-];
-const ALL_ROTATIONS = (1 << ROTATION_RULES.length) - 1;
-function rotationFor(lower, activeMask) {
-    for (let i = 0; i < ROTATION_RULES.length; i++) {
-        if ((activeMask & (1 << i)) === 0) {
-            continue;
-        }
-        const [from, to] = ROTATION_RULES[i];
-        if (lower === from) {
-            return to;
-        }
+function pick(arr, rng) {
+    return arr[Math.floor(rng() * arr.length)];
+}
+function hasTripleLetter(s) {
+    for (let i = 2; i < s.length; i++) {
+        if (s[i] === s[i - 1] && s[i] === s[i - 2])
+            return true;
     }
-    return undefined;
+    return false;
 }
-/** Choose 1..10 active consonant-rotation rules from the seeded RNG. */
-export function activeRotationMask(rng) {
-    const order = ROTATION_RULES.map((_, i) => i);
-    const activeCount = 1 + Math.floor(rng() * ROTATION_RULES.length);
-    for (let i = 0; i < activeCount; i++) {
-        const swap = i + Math.floor(rng() * (order.length - i));
-        [order[i], order[swap]] = [order[swap], order[i]];
+function junctionUgly(compound, junction) {
+    // Inspect the 4-char window centered on the junction.
+    const start = Math.max(0, junction - 2);
+    const end = Math.min(compound.length, junction + 2);
+    const win = compound.slice(start, end);
+    for (const seam of BAD_SEAMS) {
+        if (win.includes(seam))
+            return true;
     }
-    return order.slice(0, activeCount).reduce((mask, i) => mask | (1 << i), 0);
+    return false;
 }
-/** Consonant rotation. Case-preserving. Defaults to all rules for direct helper use. */
-export function mangle(s, activeMask = ALL_ROTATIONS) {
-    let out = "";
-    for (const ch of s) {
-        const lower = ch.toLowerCase();
-        const repl = rotationFor(lower, activeMask);
-        if (repl === undefined) {
-            out += ch;
-        }
-        else {
-            out += ch === lower ? repl : repl.toUpperCase();
+/** Apply one rotation at a randomly chosen matching position. */
+export function applyRotation(s, rng) {
+    const matches = [];
+    for (let i = 0; i < s.length; i++) {
+        for (const [src, dst] of ROTATIONS) {
+            if (s.slice(i, i + src.length) === src) {
+                matches.push({ i, src, dst });
+            }
         }
     }
-    return out;
+    if (matches.length === 0)
+        return s;
+    const m = matches[Math.floor(rng() * matches.length)];
+    return s.slice(0, m.i) + m.dst + s.slice(m.i + m.src.length);
 }
-const VOWELS = new Set(["a", "e", "i", "o", "u", "y"]);
-/**
- * Fuse two lowercase words at a clean junction.
- * Drops the first char of `b` while it duplicates the tail of `a`,
- * or while the seam is vowel-vowel. Max two trims.
- */
-export function joinClean(a, b) {
-    const head = a;
-    let tail = b;
-    for (let i = 0; i < 2 && head.length > 0 && tail.length > 0; i++) {
-        const last = head[head.length - 1].toLowerCase();
-        const first = tail[0].toLowerCase();
-        if (last === first) {
-            tail = tail.slice(1);
+function capitalize(s) {
+    return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+}
+/** Build one name with junction validation + one rotation. */
+export function buildName(rng) {
+    let best = "";
+    for (let attempt = 0; attempt < MAX_TRIES; attempt++) {
+        const a = pick(STEMS, rng);
+        const b = pick(STEMS, rng);
+        const compound = a + b;
+        if (compound.length > MAX_LEN) {
+            best = best || compound;
+            continue;
         }
-        else if (VOWELS.has(last) && VOWELS.has(first)) {
-            tail = tail.slice(1);
+        if (hasTripleLetter(compound)) {
+            best = best || compound;
+            continue;
         }
-        else {
-            break;
+        if (junctionUgly(compound, a.length)) {
+            best = best || compound;
+            continue;
         }
+        return capitalize(applyRotation(compound, rng));
     }
-    return head + tail;
+    // All attempts had some flaw; rotate and ship the first candidate anyway.
+    return capitalize(applyRotation(best, rng));
 }

package/dist/web.d.ts

@@ -1,2 +1,2 @@
-export { generate, mangle, joinClean, mulberry32, GEO, COMMON } from "./index.js";
+export { generate, generateMany, applyRotation, buildName, mulberry32, STEMS, ROTATIONS } from "./index.js";
 export type { NamzyOptions } from "./index.js";

package/dist/web.js

@@ -1,3 +1,3 @@
 // this_file: src/web.ts
 // Browser entry point — exposes namzy.generate() on window.namzy.
-export { generate, mangle, joinClean, mulberry32, GEO, COMMON } from "./index.js";
+export { generate, generateMany, applyRotation, buildName, mulberry32, STEMS, ROTATIONS } from "./index.js";

package/dist/wordlist.d.ts

@@ -1,2 +1,3 @@
-export declare const GEO: string[];
-export declare const COMMON: string[];
+export declare const STEMS: readonly string[];
+export declare const ROTATIONS: readonly (readonly [string, string])[];
+export declare const BAD_SEAMS: readonly string[];