@turing-machine-js/builder 2.0.1 → 3.0.1

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [3.0.1] - 2026-04-30
+
+Released in lockstep with `@turing-machine-js/machine` 3.0.1. No source or behavior changes in this package.
+
+## [3.0.0] - 2026-04-30
+
+### Changed
+
+- **Status: not actively developed by the author.** The package still works and existing tests pass; the same state-table construction pattern is now shown as an inline example in [`@turing-machine-js/machine`'s README](../machine/README.md). Most users won't need this package as a separate dependency. Contributions are welcome — see the README for areas a contributor could pick up.
+- **BREAKING** — `@turing-machine-js/machine` is now a `peerDependency` (was a regular `dependency`). npm 7+ auto-installs peers; older npm may need explicit installation.
+- Peer-dep range bumped to `^3.0.0` to require the v3 line of the engine.
+- Fixed `repository.directory` in `package.json` (was `packages/machine`, now correct `packages/builder`).
+- Internal source files now import the bare `@turing-machine-js/machine` (was `@turing-machine-js/machine/src`).
+
+### Migration
+
+If you previously had:
+
+```json
+{ "dependencies": { "@turing-machine-js/builder": "^2.0.2" } }
+```
+
+You should now have both as direct dependencies (npm 7+ does this automatically):
+
+```json
+{
+  "dependencies": {
+    "@turing-machine-js/machine": "^3.0.0",
+    "@turing-machine-js/builder": "^3.0.0"
+  }
+}
+```
+
+## [2.0.2] - earlier
+
+Initial public 2.x release.

package/README.md

@@ -0,0 +1,62 @@
+# @turing-machine-js/builder
+
+[![npm (tag)](https://img.shields.io/npm/v/@turing-machine-js/builder)](https://www.npmjs.com/package/@turing-machine-js/builder)
+
+> **Status: not actively developed by the author.** The package still works and existing tests pass — but no new features are planned. The same state-table construction pattern is shown as an inline example in [`@turing-machine-js/machine`'s README](../machine/README.md), so most users won't need this package as a separate dependency. **Contributions are welcome** if you'd like to extend it (e.g. multi-tape support, OR-patterns, a string-DSL parser shipped with the package itself).
+
+## What it does
+
+Constructs a Turing machine from a declarative state-table object. Every transition is a single `(state, currentSymbol) → (nextState, nextSymbol, movement)` row — the simplest possible API surface, matching how state machines are typically presented in textbooks.
+
+```javascript
+import { Tape } from '@turing-machine-js/machine';
+import buildMachine from '@turing-machine-js/builder';
+
+const [machine, initialState] = buildMachine({
+  alphabetString: '_01XY#',
+  initialState: 'Q8',
+  finalStateList: ['Q5'],
+  states: {
+    Q8: { '#': { state: 'Q6', symbol: '#', movement: 'R' } },
+    Q6: {
+      '0': { state: 'Q0', symbol: 'X', movement: 'R' },
+      '1': { state: 'Q1', symbol: 'Y', movement: 'R' },
+      '#': { state: 'Q2', symbol: '#', movement: 'R' },
+    },
+    // ... more states ...
+  },
+});
+
+machine.tapeBlock.replaceTape(new Tape({
+  alphabet: machine.tapeBlock.alphabets[0],
+  symbols: '#011#'.split(''),
+}));
+
+machine.run({ initialState, stepsLimit: 100 });
+// tape now contains: #011#011#  (the input duplicated)
+```
+
+See [`builder.spec.ts`](src/builder.spec.ts) for a complete worked example, including a small parser that reads the `(state,symbol)→(state,symbol,movement);` textual notation often used in textbooks.
+
+## Limitations
+
+The state-table format is intentionally minimal. It does **not** support:
+
+- **OR-patterns** (matching multiple current symbols with one transition row). For `tapeBlock.symbol('^10$')` style patterns, use the raw `@turing-machine-js/machine` API.
+- **Multi-tape machines** (`buildMachine` is single-tape only).
+- **`withOverrodeHaltState` composition** (the subroutine-call mechanism). For composed machines like `library-binary-numbers`'s `minusOne`, use the raw API.
+
+If you need any of the above, the inline state-table example in [`@turing-machine-js/machine`'s README](../machine/README.md) shows how to write your own `buildMachine`-equivalent in ~30 lines, and you can extend it to fit your case.
+
+## Install
+
+```sh
+npm install @turing-machine-js/machine @turing-machine-js/builder
+```
+
+`@turing-machine-js/machine` is a peer dependency (so consumer and library share the same singleton sentinels — `haltState`, `ifOtherSymbol`, etc.).
+
+## Links
+
+- [Turing Machine](https://en.wikipedia.org/wiki/Turing_machine) on Wikipedia
+- [`@turing-machine-js/machine`](https://github.com/mellonis/turing-machine-js/tree/master/packages/machine) — the core engine, sufficient on its own for most use cases

package/dist/index.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+var machine = require('@turing-machine-js/machine');
+
+const movementsMap = {
+    L: machine.movements.left,
+    R: machine.movements.right,
+    S: machine.movements.stay,
+};
+const referenceKey = Symbol('reference');
+const stateKey = Symbol('state');
+function buildMachine({ alphabetString, initialState, finalStateList, states: stateNameToStateDeclarationMap, }) {
+    const alphabet = new machine.Alphabet(alphabetString.split(''));
+    const machine$1 = new machine.TuringMachine({
+        tapeBlock: machine.TapeBlock.fromAlphabets([alphabet]),
+    });
+    const { symbol: getSymbol } = machine$1.tapeBlock;
+    const stateNameToStateOrReferenceMap = finalStateList.reduce((result, finalState) => ({
+        ...result,
+        [finalState]: {
+            [stateKey]: machine.haltState,
+            [referenceKey]: machine.haltState,
+        },
+    }), {});
+    Object.keys(stateNameToStateDeclarationMap).forEach((stateName) => {
+        if (stateNameToStateDeclarationMap[stateName] != null) {
+            stateNameToStateOrReferenceMap[stateName] = {
+                [referenceKey]: new machine.Reference(),
+            };
+        }
+    });
+    Object.keys(stateNameToStateDeclarationMap).forEach((stateName) => {
+        const stateDefinition = {};
+        Object.entries(stateNameToStateDeclarationMap[stateName]).forEach(([symbol, stateDeclaration]) => {
+            if (!alphabet.has(symbol)) {
+                throw new Error('invalid state declaration');
+            }
+            let nextSymbol = stateDeclaration.symbol;
+            if (nextSymbol === symbol) {
+                nextSymbol = machine.symbolCommands.keep;
+            }
+            if (nextSymbol === alphabet.blankSymbol) {
+                nextSymbol = machine.symbolCommands.erase;
+            }
+            const nextMovement = movementsMap[stateDeclaration.movement];
+            if (!nextMovement) {
+                throw new Error('invalid state declaration');
+            }
+            const nextState = stateNameToStateOrReferenceMap[stateDeclaration.state][referenceKey];
+            stateDefinition[getSymbol([symbol])] = {
+                command: {
+                    symbol: nextSymbol,
+                    movement: nextMovement,
+                },
+                nextState,
+            };
+        });
+        const state = new machine.State(stateDefinition, stateName);
+        Object.assign(stateNameToStateOrReferenceMap[stateName], {
+            [stateKey]: state,
+            [referenceKey]: stateNameToStateOrReferenceMap[stateName][referenceKey]?.bind(state),
+        });
+    });
+    const resultStates = Object.entries(stateNameToStateOrReferenceMap)
+        .reduce((result, [stateName, stateOrReference]) => ({
+        ...result,
+        [stateName]: stateOrReference[stateKey],
+    }), {});
+    return [
+        machine$1,
+        resultStates[initialState],
+        resultStates,
+    ];
+}
+
+module.exports = buildMachine;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { State, TuringMachine } from '@turing-machine-js/machine/src';
+import { State, TuringMachine } from '@turing-machine-js/machine';
 declare const movementsMap: Record<'L' | 'R' | 'S', symbol>;
 export type States = Record<string, Record<string, {
     symbol: string;

package/dist/{index.js → index.mjs}

@@ -1,4 +1,5 @@
-import { Alphabet, haltState, movements, Reference, State, symbolCommands, TapeBlock, TuringMachine, } from '@turing-machine-js/machine/src';
+import { movements, Alphabet, TuringMachine, TapeBlock, haltState, Reference, symbolCommands, State } from '@turing-machine-js/machine';
+
 const movementsMap = {
     L: movements.left,
     R: movements.right,
@@ -6,16 +7,19 @@ const movementsMap = {
 };
 const referenceKey = Symbol('reference');
 const stateKey = Symbol('state');
-export default function buildMachine({ alphabetString, initialState, finalStateList, states: stateNameToStateDeclarationMap, }) {
+function buildMachine({ alphabetString, initialState, finalStateList, states: stateNameToStateDeclarationMap, }) {
     const alphabet = new Alphabet(alphabetString.split(''));
     const machine = new TuringMachine({
         tapeBlock: TapeBlock.fromAlphabets([alphabet]),
     });
     const { symbol: getSymbol } = machine.tapeBlock;
-    const stateNameToStateOrReferenceMap = finalStateList.reduce((result, finalState) => (Object.assign(Object.assign({}, result), { [finalState]: {
+    const stateNameToStateOrReferenceMap = finalStateList.reduce((result, finalState) => ({
+        ...result,
+        [finalState]: {
             [stateKey]: haltState,
             [referenceKey]: haltState,
-        } })), {});
+        },
+    }), {});
     Object.keys(stateNameToStateDeclarationMap).forEach((stateName) => {
         if (stateNameToStateDeclarationMap[stateName] != null) {
             stateNameToStateOrReferenceMap[stateName] = {
@@ -24,7 +28,6 @@ export default function buildMachine({ alphabetString, initialState, finalStateL
         }
     });
     Object.keys(stateNameToStateDeclarationMap).forEach((stateName) => {
-        var _a;
         const stateDefinition = {};
         Object.entries(stateNameToStateDeclarationMap[stateName]).forEach(([symbol, stateDeclaration]) => {
             if (!alphabet.has(symbol)) {
@@ -53,14 +56,19 @@ export default function buildMachine({ alphabetString, initialState, finalStateL
         const state = new State(stateDefinition, stateName);
         Object.assign(stateNameToStateOrReferenceMap[stateName], {
             [stateKey]: state,
-            [referenceKey]: (_a = stateNameToStateOrReferenceMap[stateName][referenceKey]) === null || _a === void 0 ? void 0 : _a.bind(state),
+            [referenceKey]: stateNameToStateOrReferenceMap[stateName][referenceKey]?.bind(state),
         });
     });
     const resultStates = Object.entries(stateNameToStateOrReferenceMap)
-        .reduce((result, [stateName, stateOrReference]) => (Object.assign(Object.assign({}, result), { [stateName]: stateOrReference[stateKey] })), {});
+        .reduce((result, [stateName, stateOrReference]) => ({
+        ...result,
+        [stateName]: stateOrReference[stateKey],
+    }), {});
     return [
         machine,
         resultStates[initialState],
         resultStates,
     ];
 }
+
+export { buildMachine as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@turing-machine-js/builder",
-  "version": "2.0.1",
-  "description": "A turing machine builder",
+  "version": "3.0.1",
+  "description": "A turing machine builder — declarative state-table construction. Not actively developed by the author; the same state-table pattern is also shown as an inline example in @turing-machine-js/machine's README. Contributions welcome.",
   "engines": {
     "npm": ">=7.0.0"
   },
@@ -14,7 +14,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/mellonis/turing-machine-js.git",
-    "directory": "packages/machine"
+    "directory": "packages/builder"
   },
   "bugs": {
     "url": "https://github.com/mellonis/turing-machine-js/issues?utf8=✓&q=is%3Aissue+is%3Aopen+label%3A%22pkg%3A+builder%22+label%3Abug"
@@ -24,18 +24,19 @@
     "machine",
     "builder"
   ],
-  "dependencies": {
-    "@turing-machine-js/machine": "^2.0.1"
+  "peerDependencies": {
+    "@turing-machine-js/machine": "^3.0.0"
   },
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
     }
   },
-  "gitHead": "18d8a7388cea7372a9e262452797699cea7b61dd"
+  "gitHead": "0a8d7ff87a3a73ea7ee1844f7f4602cbb23d20fe"
 }

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/index.ts"],"version":"5.9.3"}