@knitting-tools/core 2.0.0 → 2.0.1

package/README.md

@@ -9,12 +9,54 @@ A knitting pattern engine for expanding rows, applying shaping, and compiling pa
 - Apply physical shaping to stitch streams
 - Compile simple knitting DSL
 
+## Package boundaries
+
+`@knitting-tools/core` is the pattern engine package.
+
+- Keep here: parsing, shaping, row expansion, and compile pipeline.
+- Use `@knitting-tools/math` for gauge and measurement utility functions.
+
 ## Install
 
 ```bash
 pnpm add @knitting-tools/core
 ```
 
+## Migration from @knitting-tools/math
+
+The package was renamed in `2.0.0`:
+
+- Old package: `@knitting-tools/math`
+- New package: `@knitting-tools/core`
+
+Update your project by changing both install and import paths.
+
+Before:
+
+```ts
+import { compilePattern } from "@knitting-tools/math";
+```
+
+After:
+
+```ts
+import { compilePattern } from "@knitting-tools/core";
+```
+
+The runtime API surface is unchanged for this rename; migration is package-path only.
+
+For split-package migration, prefer these utility imports from `@knitting-tools/math`:
+
+- `rowsPerCm`
+- `stitchesPerCm`
+- `cmToRows`
+- `cmToStitches`
+- `convertLength`
+- `normaliseMeasurement`
+- `roundStitches`
+
+These remain re-exported from `@knitting-tools/core` for compatibility.
+
 ## Quick example
 
 ```ts

package/dist/index.d.ts

@@ -1,78 +1,13 @@
+import { Gauge } from '@knitting-tools/math';
+export { Gauge, ImperialGauge, MetricGauge, UnitSystem, cmToRows, cmToStitches, convertLength, normaliseMeasurement, roundStitches, rowsPerCm, stitchesPerCm } from '@knitting-tools/math';
+
 declare const INCH_TO_CM: number;
 declare const CM_TO_INCH: number;
 declare const MM_TO_CM: number;
 declare const CM_TO_MM: number;
 
-type UnitSystem = "imperial" | "metric";
-interface MetricGauge {
-    rowsPer10cm: number;
-    stitchesPer10cm: number;
-    unit: "metric";
-}
-interface ImperialGauge {
-    rowsPer4in: number;
-    stitchesPer4in: number;
-    unit: "imperial";
-}
-type Gauge = MetricGauge | ImperialGauge;
-/**
- * Get the number of stitches per centimeter based on the gauge.
- *
- * @param gauge - The gauge information.
- * @returns The number of stitches per centimeter.
- */
-declare function stitchesPerCm(gauge: Gauge): number;
-/**
- * Get the number of rows per centimeter based on the gauge.
- *
- * @param gauge - The gauge information.
- * @returns The number of rows per centimeter.
- */
-declare function rowsPerCm(gauge: Gauge): number;
-
-/**
- * Convert a centimetre measurement into a rounded stitch count for the given gauge.
- *
- * @param cm - The measurement in centimetres.
- * @param gauge - The gauge definition used for conversion.
- * @returns The nearest whole-number stitch count.
- */
-declare function cmToStitches(cm: number, gauge: Gauge): number;
-/**
- * Convert a centimetre measurement into a rounded row count for the given gauge.
- *
- * @param cm - The measurement in centimetres.
- * @param gauge - The gauge definition used for conversion.
- * @returns The nearest whole-number row count.
- */
-declare function cmToRows(cm: number, gauge: Gauge): number;
-
-/**
- * Convert a length value between centimeters and inches.
- *
- * @param value - The length value to convert.
- * @param from - The unit of the input value ("cm" or "in").
- * @param to - The unit to convert to ("cm" or "in").
- * @returns The converted length value.
- */
-declare function convertLength(value: number, from: "cm" | "in", to: "cm" | "in"): number;
-/**
- * Normalise a length measurement to centimeters.
- *
- * @param value - The length value to normalise.
- * @param unit - The unit of the input value ("cm" or "in").
- * @returns The normalised length value in centimeters.
- */
-declare function normaliseMeasurement(value: number, unit: "cm" | "in"): number;
-/**
- * Round a number of stitches to the nearest whole number.
- *
- * @param stitches - The number of stitches to round.
- * @returns The rounded number of stitches.
- */
-declare function roundStitches(stitches: number): number;
-
 type StitchType = "knit" | "purl" | "decrease" | "increase";
+type OperationType = "decrease" | "increase";
 type StitchVariant = "inv-l" | "inv-r" | "k1-b" | "k2tog" | "kfb" | "kfbf" | "m1" | "p1-b" | "p2tog" | "pfb" | "psso" | "s2kp" | "sk2p" | "skp" | "sl" | "sl1" | "slip" | "ssp" | "ssk" | "tbl" | "yfon" | "yfrn" | "yo" | "yon" | "yrn";
 type StitchVariantParameterValue = boolean | number | string;
 type StitchVariantParameters = Record<string, StitchVariantParameterValue>;
@@ -94,6 +29,7 @@ type EdgeElement = ShapingElement | StitchInstruction;
 type RowElement = ShapingElement | StitchInstruction | RepeatBlock;
 interface StitchInstruction {
     count: number;
+    operation?: OperationType;
     type: StitchType;
     variant?: StitchVariant;
     variantParameters?: StitchVariantParameters;
@@ -338,6 +274,65 @@ declare function createDefaultStitchRegistry(): StitchRegistry;
  */
 declare function createEmptyStitchRegistry(): StitchRegistry;
 
+type ShapingType = "decrease" | "increase";
+
+interface ShapeRowInput {
+    alignment?: "left" | "center" | "right";
+    row: Row;
+    shaping: {
+        type: ShapingType;
+        count: number;
+    };
+    totalStitches: number;
+}
+interface ShapedStitch {
+    isShaping?: boolean;
+    operationIndex?: number;
+    shapingType?: ShapingType;
+    sourceIndex: number;
+    type: StitchType;
+}
+interface ShapeRowResult {
+    shapedStitches: ShapedStitch[];
+    stitches: StitchInstruction[];
+    totalStitches: number;
+}
+interface ShapingOperationGroup {
+    operationIndex: number;
+    outputIndices: number[];
+    shapingType: ShapingType;
+    sourceIndices: number[];
+    stitches: ShapedStitch[];
+}
+interface CompileRowInput {
+    alignment?: "left" | "center" | "right";
+    row: Row;
+    shaping?: {
+        count: number;
+        type: ShapingType;
+    };
+    totalStitches: number;
+}
+interface CompileRowResult {
+    shapedStitches?: ShapedStitch[];
+    stitches: StitchInstruction[];
+    totalStitches: number;
+}
+
+/**
+ * Options object for the shaping-aware overload of compileRowDsl /
+ * compileCompatibleRowDsl.  Pass this instead of a plain registry when you
+ * want DSL parsing, expansion, and shaping in a single call.
+ */
+interface CompileRowDslOptions {
+    alignment?: "left" | "center" | "right";
+    registry?: StitchRegistry;
+    shaping?: {
+        count: number;
+        type: ShapingType;
+    };
+}
+
 interface RowDslAstEdgeStartElement {
     stitches: EdgeElement[];
     type: "edge-start";
@@ -366,42 +361,14 @@ declare function isRowDslAstWellFormed(ast: RowDslAst): boolean;
 declare function parseRowDsl(input: string, registry?: StitchRegistry): Row;
 declare function parseCompatibleRowDsl(input: string, registry?: StitchRegistry): Row;
 declare function compileRowDsl(input: string, totalStitches: number, registry?: StitchRegistry): StitchInstruction[];
+declare function compileRowDsl(input: string, totalStitches: number, options: CompileRowDslOptions): CompileRowResult;
 declare function compileCompatibleRowDsl(input: string, totalStitches: number, registry?: StitchRegistry): StitchInstruction[];
+declare function compileCompatibleRowDsl(input: string, totalStitches: number, options: CompileRowDslOptions): CompileRowResult;
 declare function rowToRowDsl(row: Row): string;
 declare function parseRowDslAst(input: string, registry?: StitchRegistry): RowDslAst;
 declare function parseCompatibleRowDslAst(input: string, registry?: StitchRegistry): RowDslAst;
 declare function resolveRowDslAst(ast: RowDslAst): Row;
 
-type ShapingType = "decrease" | "increase";
-
-interface ShapeRowInput {
-    row: Row;
-    shaping: {
-        type: ShapingType;
-        count: number;
-    };
-    totalStitches: number;
-}
-interface ShapedStitch {
-    isShaping?: boolean;
-    operationIndex?: number;
-    shapingType?: ShapingType;
-    sourceIndex: number;
-    type: StitchType;
-}
-interface ShapeRowResult {
-    shapedStitches: ShapedStitch[];
-    stitches: StitchInstruction[];
-    totalStitches: number;
-}
-interface ShapingOperationGroup {
-    operationIndex: number;
-    outputIndices: number[];
-    shapingType: ShapingType;
-    sourceIndices: number[];
-    stitches: ShapedStitch[];
-}
-
 type ShapingDslParseResult = ShapeRowInput;
 type ShapingDslElement = {
     row: Row;
@@ -474,7 +441,8 @@ declare function printShapingDebug(shapedStitches: ShapedStitch[], label?: strin
 declare function parseShapingDslAst(input: string): ShapingDslAst;
 declare function parseShapingDsl(input: string): ShapingDslParseResult;
 declare function compileShapingDsl(input: string): ShapeRowResult;
+declare function compileRow(input: CompileRowInput): CompileRowResult;
 declare function shapeRow(input: ShapeRowInput): ShapeRowResult;
 declare function groupShapedStitchesByOperation(shapedStitches: ShapedStitch[]): ShapingOperationGroup[];
 
-export { CM_TO_INCH, CM_TO_MM, type CastOnInput, type CompilePatternOptions, type CompiledPattern, type CompiledPatternRow, type EdgeElement, type Gauge, INCH_TO_CM, type ImperialGauge, KnittingMathError, type KnittingMathErrorCode, type KnittingMathErrorContext, KnittingMathExpansionError, KnittingMathParseError, KnittingMathValidationError, MM_TO_CM, type MetricGauge, type Pattern, type PatternCompileMode, type RepeatBlock, type ResolveOptions, type Row, type RowDslAst, type RowDslAstElement, type RowElement, type RowShapingOperation, type ShapeRowInput, type ShapeRowResult, type ShapedRowResult, type ShapedStitch, type ShapingDebugLine, type ShapingDebugOptions, type ShapingDslAst, type ShapingDslElement, type ShapingDslParseResult, type ShapingElement, type ShapingOperationGroup, type StitchInstruction, type StitchRegistry, type StitchType, type StitchVariant, type StitchVariantParameterValue, type StitchVariantParameters, type UnitSystem, calculateCastOn, calculateCastOnStitches, cmToRows, cmToStitches, compileCompatibleRowDsl, compilePattern, compileRowDsl, compileShapingDsl, convertLength, countStitchesInInstructions, createDefaultStitchRegistry, createEmptyStitchRegistry, createRepeatRow, ensureKnittingMathError, expandPattern, expandRow, expandRowToStitchTypes, expandRowToStitches, groupShapedStitchesByOperation, isRowDslAstWellFormed, normaliseMeasurement, parseCompatibleRowDsl, parseCompatibleRowDslAst, parseRowDsl, parseRowDslAst, parseShapingDsl, parseShapingDslAst, printPattern, printShapingDebug, renderShapingDebug, renderShapingDebugForInput, resolveRowDslAst, roundStitches, rowToRowDsl, rowsPerCm, shapeRow, shapedExpandPattern, stitchesPerCm };
+export { CM_TO_INCH, CM_TO_MM, type CastOnInput, type CompilePatternOptions, type CompileRowDslOptions, type CompileRowInput, type CompileRowResult, type CompiledPattern, type CompiledPatternRow, type EdgeElement, INCH_TO_CM, KnittingMathError, type KnittingMathErrorCode, type KnittingMathErrorContext, KnittingMathExpansionError, KnittingMathParseError, KnittingMathValidationError, MM_TO_CM, type Pattern, type PatternCompileMode, type RepeatBlock, type ResolveOptions, type Row, type RowDslAst, type RowDslAstElement, type RowElement, type RowShapingOperation, type ShapeRowInput, type ShapeRowResult, type ShapedRowResult, type ShapedStitch, type ShapingDebugLine, type ShapingDebugOptions, type ShapingDslAst, type ShapingDslElement, type ShapingDslParseResult, type ShapingElement, type ShapingOperationGroup, type StitchInstruction, type StitchRegistry, type StitchType, type StitchVariant, type StitchVariantParameterValue, type StitchVariantParameters, calculateCastOn, calculateCastOnStitches, compileCompatibleRowDsl, compilePattern, compileRow, compileRowDsl, compileShapingDsl, countStitchesInInstructions, createDefaultStitchRegistry, createEmptyStitchRegistry, createRepeatRow, ensureKnittingMathError, expandPattern, expandRow, expandRowToStitchTypes, expandRowToStitches, groupShapedStitchesByOperation, isRowDslAstWellFormed, parseCompatibleRowDsl, parseCompatibleRowDslAst, parseRowDsl, parseRowDslAst, parseShapingDsl, parseShapingDslAst, printPattern, printShapingDebug, renderShapingDebug, renderShapingDebugForInput, resolveRowDslAst, rowToRowDsl, shapeRow, shapedExpandPattern };

package/dist/index.js

@@ -4,58 +4,26 @@ var CM_TO_INCH = 1 / INCH_TO_CM;
 var MM_TO_CM = 0.1;
 var CM_TO_MM = 10;
 
-// src/gauge/gauge.ts
-var unitToCm = (value, unit) => {
-  if (unit === "metric") return value / 10;
-  else return value / 4 / INCH_TO_CM;
-};
-function stitchesPerCm(gauge) {
-  if (gauge.unit === "metric") {
-    return unitToCm(gauge.stitchesPer10cm, "metric");
-  }
-  return unitToCm(gauge.stitchesPer4in, "imperial");
-}
-function rowsPerCm(gauge) {
-  if (gauge.unit === "metric") {
-    return unitToCm(gauge.rowsPer10cm, "metric");
-  }
-  return unitToCm(gauge.rowsPer4in, "imperial");
-}
-
-// src/gauge/conversion.ts
-function cmToStitches(cm, gauge) {
-  return Math.round(stitchesPerCm(gauge) * cm);
-}
-function cmToRows(cm, gauge) {
-  return Math.round(rowsPerCm(gauge) * cm);
-}
-
-// src/measurement/measurement.ts
-function convertLength(value, from, to) {
-  if (from === to) {
-    return value;
-  }
-  if (from === "cm" && to === "in") {
-    return value * CM_TO_INCH;
-  }
-  if (from === "in" && to === "cm") {
-    return value * INCH_TO_CM;
-  }
-  throw new Error(`Unsupported conversion from ${from} \u2192 ${to}`);
-}
-function normaliseMeasurement(value, unit) {
-  return convertLength(value, unit, "cm");
-}
-function roundStitches(stitches) {
-  if (!Number.isFinite(stitches)) {
-    throw new Error("Stitch count must be a finite number.");
-  }
-  return Math.round(stitches);
-}
+// src/public/index.ts
+import {
+  CM_TO_INCH as CM_TO_INCH2,
+  CM_TO_MM as CM_TO_MM2,
+  INCH_TO_CM as INCH_TO_CM2,
+  MM_TO_CM as MM_TO_CM2,
+  cmToRows,
+  cmToStitches,
+  convertLength,
+  normaliseMeasurement as normaliseMeasurement2,
+  roundStitches as roundStitches2,
+  rowsPerCm,
+  stitchesPerCm as stitchesPerCm2
+} from "@knitting-tools/math";
 
 // src/pattern/row.ts
 var InstructionBuffer = class {
-  items = [];
+  constructor() {
+    this.items = [];
+  }
   append(instruction, count = instruction.count) {
     this.items[this.items.length] = cloneInstruction(instruction, count);
   }
@@ -71,6 +39,15 @@ var SHAPING_PRODUCE = {
   decrease: 1,
   increase: 2
 };
+function getInstructionOperation(instruction) {
+  if (instruction.operation !== void 0) {
+    return instruction.operation;
+  }
+  if (instruction.type === "decrease" || instruction.type === "increase") {
+    return instruction.type;
+  }
+  return void 0;
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -87,10 +64,10 @@ function isStitchInstruction(element) {
   return !isRepeatBlock(element) && !isShapingElement(element);
 }
 function countEdgeSourceStitches(stitches) {
-  return (stitches == null ? void 0 : stitches.reduce(
+  return stitches?.reduce(
     (sum, stitch) => sum + (isEdgeShapingElement(stitch) ? stitch.count * SHAPING_CONSUME[stitch.shapingType] : stitch.count),
     0
-  )) ?? 0;
+  ) ?? 0;
 }
 function countSequenceStitches(elements) {
   let total = 0;
@@ -119,12 +96,21 @@ function cloneVariantParameters(variantParameters) {
   return variantParameters ? { ...variantParameters } : void 0;
 }
 function cloneInstruction(instruction, count = instruction.count) {
-  return {
+  const clone = {
     count,
-    type: instruction.type,
-    variant: instruction.variant,
-    variantParameters: cloneVariantParameters(instruction.variantParameters)
+    type: instruction.type
   };
+  if (instruction.operation !== void 0) {
+    clone.operation = instruction.operation;
+  }
+  if (instruction.variant !== void 0) {
+    clone.variant = instruction.variant;
+  }
+  const clonedVariantParameters = cloneVariantParameters(instruction.variantParameters);
+  if (clonedVariantParameters !== void 0) {
+    clone.variantParameters = clonedVariantParameters;
+  }
+  return clone;
 }
 function inferDecreaseVariant(element) {
   const isPurl = element.stitch === "purl";
@@ -155,12 +141,18 @@ function inferShapingVariant(element) {
 }
 function createInstructionFromShaping(element, operationCount) {
   const inferredVariant = element.variant ?? inferShapingVariant(element);
-  return {
+  const instruction = {
     count: operationCount * SHAPING_PRODUCE[element.shapingType],
-    type: element.shapingType,
-    variant: inferredVariant,
-    variantParameters: cloneVariantParameters(element.variantParameters)
+    type: element.shapingType
   };
+  if (inferredVariant !== void 0) {
+    instruction.variant = inferredVariant;
+  }
+  const clonedVariantParameters = cloneVariantParameters(element.variantParameters);
+  if (clonedVariantParameters !== void 0) {
+    instruction.variantParameters = clonedVariantParameters;
+  }
+  return instruction;
 }
 function areVariantParametersEqual(left, right) {
   if (left === right) {
@@ -182,7 +174,7 @@ function areVariantParametersEqual(left, right) {
   return true;
 }
 function canMergeInstructions(left, right) {
-  return left.type === right.type && left.variant === right.variant && areVariantParametersEqual(left.variantParameters, right.variantParameters);
+  return left.operation === right.operation && left.type === right.type && left.variant === right.variant && areVariantParametersEqual(left.variantParameters, right.variantParameters);
 }
 function assertPositiveInteger(value, label) {
   if (!Number.isInteger(value) || value <= 0) {
@@ -214,6 +206,9 @@ function validateStitchInstruction(instruction, path) {
   if (!isRecord(instruction)) {
     throw new Error(`${path} must be an object.`);
   }
+  if (instruction.operation !== void 0 && instruction.operation !== "decrease" && instruction.operation !== "increase") {
+    throw new Error(`${path}.operation must be 'decrease' or 'increase' when provided.`);
+  }
   assertPositiveInteger(instruction.count, `${path}.count`);
   validateVariantParameters(instruction.variantParameters, `${path}.variantParameters`);
 }
@@ -861,7 +856,6 @@ function collectRowShaping(row) {
   return ops;
 }
 function compilePattern(pattern, initialStitches, options = {}) {
-  var _a;
   const mode = options.mode ?? "shaped";
   const rows = [];
   let currentStitches = initialStitches;
@@ -893,7 +887,7 @@ function compilePattern(pattern, initialStitches, options = {}) {
     }
   }
   return {
-    finalStitches: ((_a = rows.at(-1)) == null ? void 0 : _a.carriedStitches) ?? initialStitches,
+    finalStitches: rows.at(-1)?.carriedStitches ?? initialStitches,
     initialStitches,
     mode,
     rows
@@ -917,10 +911,11 @@ function printPattern(pattern, stitchesPerRow) {
   const expanded = expandPattern(pattern, stitchesPerRow);
   expanded.forEach((row, rowIndex) => {
     const rowStr = row.map((stitch) => {
-      const symbol = stitchSymbols[stitch.type] ?? "?";
+      const operation = getInstructionOperation(stitch);
+      const symbol = operation ? stitchSymbols[operation] : stitchSymbols[stitch.type] ?? "?";
       return symbol.repeat(stitch.count);
     }).join(" ");
-    patternDebugLogger == null ? void 0 : patternDebugLogger.log(`Row ${rowIndex + 1}: ${rowStr}`);
+    patternDebugLogger?.log(`Row ${rowIndex + 1}: ${rowStr}`);
   });
 }
 function createRepeatRow(sequence, times) {
@@ -937,8 +932,6 @@ function createRepeatRow(sequence, times) {
 
 // src/public/errors.ts
 var KnittingMathError = class extends Error {
-  code;
-  context;
   constructor(name, code, message, context, cause) {
     super(message);
     this.name = name;
@@ -1019,6 +1012,11 @@ function printPattern2(pattern, stitchesPerRow) {
 }
 
 // src/stitches/castOn.ts
+import {
+  normaliseMeasurement,
+  roundStitches,
+  stitchesPerCm
+} from "@knitting-tools/math";
 function calculateCastOn(input) {
   return calculateCastOnStitches({ ...input, ease: 0 });
 }
@@ -1034,6 +1032,163 @@ function calculateCastOnStitches(input) {
   return roundStitches(stitches);
 }
 
+// src/shaping/distribution.ts
+function distributeEvenly(totalStitches, operations) {
+  if (operations <= 0) {
+    return { spacing: [] };
+  }
+  const baseSpacing = Math.floor(totalStitches / operations);
+  const remainder = totalStitches % operations;
+  const spacing = [];
+  for (let i = 0; i < operations; i++) {
+    const shouldAddExtra = Math.floor(i * remainder / operations) !== Math.floor((i + 1) * remainder / operations);
+    spacing.push(baseSpacing + (shouldAddExtra ? 1 : 0));
+  }
+  return { spacing };
+}
+
+// src/shaping/shapingRules.ts
+var SHAPING_RULES = {
+  decrease: { consume: 2, produce: 1 },
+  // k2tog -  A decrease consumes 2 stitches and produces 1.
+  increase: { consume: 1, produce: 2 }
+  // M1 - An increase consumes 1 stitch and produces 2 stitches.
+};
+
+// src/shaping/shaping.ts
+function getShapingPositions(length, count, alignment = "center") {
+  if (count <= 0 || length <= 0) {
+    return [];
+  }
+  const { spacing } = distributeEvenly(length, count);
+  const positions = [];
+  let current = 0;
+  for (const gap of spacing) {
+    let position;
+    switch (alignment) {
+      case "left":
+        position = current;
+        break;
+      case "center":
+        position = current + Math.floor(gap / 2);
+        break;
+      case "right":
+        position = current + gap - 1;
+        break;
+    }
+    positions.push(position);
+    current += gap;
+  }
+  return positions.filter((position) => position >= 0 && position < length);
+}
+function applyPhysicalShaping(stitches, shapingType, positions) {
+  const rule = SHAPING_RULES[shapingType];
+  const result = [];
+  let i = 0;
+  let positionIndex = 0;
+  while (i < stitches.length) {
+    if (positionIndex < positions.length && i === positions[positionIndex]) {
+      if (i + rule.consume > stitches.length) {
+        throw new Error("Shaping operation exceeds available stitches at the selected position.");
+      }
+      for (let j = 0; j < rule.produce; j++) {
+        result.push({
+          isShaping: true,
+          operationIndex: positionIndex,
+          shapingType,
+          sourceIndex: i,
+          type: shapingType
+        });
+      }
+      i += rule.consume;
+      positionIndex++;
+    } else {
+      result.push(stitches[i]);
+      i++;
+    }
+  }
+  return result;
+}
+function compressStitches(stitches) {
+  const result = [];
+  for (const stitch of stitches) {
+    const last = result.at(-1);
+    if (last?.type === stitch.type) {
+      last.count++;
+    } else {
+      result.push({ type: stitch.type, count: 1 });
+    }
+  }
+  return result;
+}
+function shapeRow(input) {
+  const { row, totalStitches, shaping } = input;
+  if (shaping.count < 0) {
+    throw new Error("Shaping count must be 0 or greater.");
+  }
+  const expanded = expandRowToStitchTypes(row, totalStitches).map((type, sourceIndex) => ({
+    sourceIndex,
+    type
+  }));
+  const rule = SHAPING_RULES[shaping.type];
+  if (shaping.count * rule.consume > expanded.length) {
+    throw new Error("Cannot apply more shaping operations than stitches in the row.");
+  }
+  const shapingPositions = getShapingPositions(
+    expanded.length,
+    shaping.count,
+    input.alignment ?? "center"
+  );
+  const shapedStitches = applyPhysicalShaping(expanded, shaping.type, shapingPositions);
+  const stitches = compressStitches(shapedStitches);
+  const resultingStitches = totalStitches + shaping.count * (rule.produce - rule.consume);
+  return { shapedStitches, stitches, totalStitches: resultingStitches };
+}
+function groupShapedStitchesByOperation(shapedStitches) {
+  const groups = /* @__PURE__ */ new Map();
+  for (let outputIndex = 0; outputIndex < shapedStitches.length; outputIndex += 1) {
+    const stitch = shapedStitches[outputIndex];
+    if (!stitch.isShaping || stitch.operationIndex === void 0 || stitch.shapingType === void 0) {
+      continue;
+    }
+    const existing = groups.get(stitch.operationIndex);
+    if (existing) {
+      if (existing.shapingType !== stitch.shapingType) {
+        throw new Error("Shaping operation contains mixed shaping types.");
+      }
+      existing.stitches.push(stitch);
+      existing.outputIndices.push(outputIndex);
+      existing.sourceIndices.push(stitch.sourceIndex);
+      continue;
+    }
+    groups.set(stitch.operationIndex, {
+      operationIndex: stitch.operationIndex,
+      outputIndices: [outputIndex],
+      shapingType: stitch.shapingType,
+      sourceIndices: [stitch.sourceIndex],
+      stitches: [stitch]
+    });
+  }
+  return Array.from(groups.values());
+}
+function compileRow(input) {
+  const { row, totalStitches, shaping, alignment } = input;
+  if (!shaping || shaping.count === 0) {
+    return { stitches: expandRow(row, totalStitches), totalStitches };
+  }
+  const {
+    shapedStitches,
+    stitches,
+    totalStitches: resultingStitches
+  } = shapeRow({
+    alignment,
+    row,
+    shaping,
+    totalStitches
+  });
+  return { shapedStitches, stitches, totalStitches: resultingStitches };
+}
+
 // src/parser/compatibilityNormaliser.ts
 function isWordBoundaryCharacter(char) {
   return char === void 0 || /[^a-z]/i.test(char);
@@ -1346,10 +1501,12 @@ var ERR_DEFAULT_COUNT_INVALID = "Default count must be a positive integer.";
 var ERR_RESOLVE_OPTIONS_INVALID = "Resolve options must be an object when provided.";
 var ERR_RESOLVE_THROW_ON_UNKNOWN_INVALID = "Resolve option 'throwOnUnknown' must be a boolean when provided.";
 var InMemoryStitchRegistry = class {
-  typeMap = /* @__PURE__ */ new Map();
-  abbreviationMap = /* @__PURE__ */ new Map();
-  defaultCounts = /* @__PURE__ */ new Map();
-  lockedCountVariants = /* @__PURE__ */ new Set();
+  constructor() {
+    this.typeMap = /* @__PURE__ */ new Map();
+    this.abbreviationMap = /* @__PURE__ */ new Map();
+    this.defaultCounts = /* @__PURE__ */ new Map();
+    this.lockedCountVariants = /* @__PURE__ */ new Set();
+  }
   /**
    * Normalise a required token for storage.
    *
@@ -1524,10 +1681,8 @@ function createEmptyStitchRegistry() {
 var SHAPING_TOKEN_RE = /^shape-(dec|decrease|inc|increase)(?:-(l|left|r|right|c|centre|center))?(\d+)$/;
 var COMPACT_STITCH_TOKEN_RE = /^([a-z-]+)(\d+)$/i;
 var RowDslParser = class {
-  input;
-  registry;
-  index = 0;
   constructor(input, registry) {
+    this.index = 0;
     this.input = input;
     this.registry = registry ?? createDefaultStitchRegistry();
   }
@@ -2067,6 +2222,9 @@ function resolveRowDslAst(ast) {
 }
 
 // src/parser/rowDsl.ts
+function isStitchRegistry(value) {
+  return typeof value.isKnown === "function";
+}
 function parseWithAstParser(parser, input, registry) {
   return resolveRowDslAst(parser(input, registry));
 }
@@ -2079,11 +2237,24 @@ function parseRowDsl(input, registry) {
 function parseCompatibleRowDsl(input, registry) {
   return parseWithAstParser(parseCompatibleRowDslAst, input, registry);
 }
-function compileRowDsl(input, totalStitches, registry) {
-  return compileWithParser(parseRowDsl, input, totalStitches, registry);
-}
-function compileCompatibleRowDsl(input, totalStitches, registry) {
-  return compileWithParser(parseCompatibleRowDsl, input, totalStitches, registry);
+function compileRowDsl(input, totalStitches, registryOrOptions) {
+  if (registryOrOptions !== void 0 && !isStitchRegistry(registryOrOptions)) {
+    const { registry, shaping, alignment } = registryOrOptions;
+    return compileRow({ row: parseRowDsl(input, registry), totalStitches, shaping, alignment });
+  }
+  return compileWithParser(parseRowDsl, input, totalStitches, registryOrOptions);
+}
+function compileCompatibleRowDsl(input, totalStitches, registryOrOptions) {
+  if (registryOrOptions !== void 0 && !isStitchRegistry(registryOrOptions)) {
+    const { registry, shaping, alignment } = registryOrOptions;
+    return compileRow({
+      row: parseCompatibleRowDsl(input, registry),
+      totalStitches,
+      shaping,
+      alignment
+    });
+  }
+  return compileWithParser(parseCompatibleRowDsl, input, totalStitches, registryOrOptions);
 }
 
 // src/public/parser.ts
@@ -2119,16 +2290,34 @@ function parseCompatibleRowDsl2(input, registry) {
     throw wrapParseError(error, "parseCompatibleRowDsl");
   }
 }
-function compileRowDsl2(input, totalStitches, registry) {
+function compileRowDsl2(input, totalStitches, registryOrOptions) {
   try {
-    return compileRowDsl(input, totalStitches, registry);
+    if (registryOrOptions !== void 0 && typeof registryOrOptions.isKnown !== "function") {
+      return compileRowDsl(input, totalStitches, registryOrOptions);
+    }
+    return compileRowDsl(
+      input,
+      totalStitches,
+      registryOrOptions
+    );
   } catch (error) {
     throw wrapExpansionError2(error, "compileRowDsl");
   }
 }
-function compileCompatibleRowDsl2(input, totalStitches, registry) {
+function compileCompatibleRowDsl2(input, totalStitches, registryOrOptions) {
   try {
-    return compileCompatibleRowDsl(input, totalStitches, registry);
+    if (registryOrOptions !== void 0 && typeof registryOrOptions.isKnown !== "function") {
+      return compileCompatibleRowDsl(
+        input,
+        totalStitches,
+        registryOrOptions
+      );
+    }
+    return compileCompatibleRowDsl(
+      input,
+      totalStitches,
+      registryOrOptions
+    );
   } catch (error) {
     throw wrapExpansionError2(error, "compileCompatibleRowDsl");
   }
@@ -2162,127 +2351,6 @@ function resolveRowDslAst2(ast) {
   }
 }
 
-// src/shaping/distribution.ts
-function distributeEvenly(totalStitches, operations) {
-  if (operations <= 0) {
-    return { spacing: [] };
-  }
-  const baseSpacing = Math.floor(totalStitches / operations);
-  const remainder = totalStitches % operations;
-  const spacing = [];
-  for (let i = 0; i < operations; i++) {
-    const shouldAddExtra = Math.floor(i * remainder / operations) !== Math.floor((i + 1) * remainder / operations);
-    spacing.push(baseSpacing + (shouldAddExtra ? 1 : 0));
-  }
-  return { spacing };
-}
-
-// src/shaping/shapingRules.ts
-var SHAPING_RULES = {
-  decrease: { consume: 2, produce: 1 },
-  // k2tog -  A decrease consumes 2 stitches and produces 1.
-  increase: { consume: 1, produce: 2 }
-  // M1 - An increase consumes 1 stitch and produces 2 stitches.
-};
-
-// src/shaping/shaping.ts
-function getShapingPositions(length, count) {
-  if (count <= 0 || length <= 0) {
-    return [];
-  }
-  const { spacing } = distributeEvenly(length, count);
-  const positions = [];
-  let current = 0;
-  for (const gap of spacing) {
-    positions.push(current);
-    current += gap;
-  }
-  return positions.filter((position) => position >= 0 && position < length);
-}
-function applyPhysicalShaping(stitches, shapingType, positions) {
-  const rule = SHAPING_RULES[shapingType];
-  const result = [];
-  let i = 0;
-  let positionIndex = 0;
-  while (i < stitches.length) {
-    if (positionIndex < positions.length && i === positions[positionIndex]) {
-      for (let j = 0; j < rule.produce; j++) {
-        result.push({
-          isShaping: true,
-          operationIndex: positionIndex,
-          shapingType,
-          sourceIndex: i,
-          type: shapingType
-        });
-      }
-      i += rule.consume;
-      positionIndex++;
-    } else {
-      result.push(stitches[i]);
-      i++;
-    }
-  }
-  return result;
-}
-function compressStitches(stitches) {
-  const result = [];
-  for (const stitch of stitches) {
-    const last = result.at(-1);
-    if ((last == null ? void 0 : last.type) === stitch.type) {
-      last.count++;
-    } else {
-      result.push({ type: stitch.type, count: 1 });
-    }
-  }
-  return result;
-}
-function shapeRow(input) {
-  const { row, totalStitches, shaping } = input;
-  if (shaping.count < 0) {
-    throw new Error("Shaping count must be 0 or greater.");
-  }
-  const expanded = expandRowToStitchTypes(row, totalStitches).map((type, sourceIndex) => ({
-    sourceIndex,
-    type
-  }));
-  const rule = SHAPING_RULES[shaping.type];
-  if (shaping.count * rule.consume > expanded.length) {
-    throw new Error("Cannot apply more shaping operations than stitches in the row.");
-  }
-  const shapingPositions = getShapingPositions(expanded.length, shaping.count);
-  const shapedStitches = applyPhysicalShaping(expanded, shaping.type, shapingPositions);
-  const stitches = compressStitches(shapedStitches);
-  const resultingStitches = totalStitches + shaping.count * (rule.produce - rule.consume);
-  return { shapedStitches, stitches, totalStitches: resultingStitches };
-}
-function groupShapedStitchesByOperation(shapedStitches) {
-  const groups = /* @__PURE__ */ new Map();
-  for (let outputIndex = 0; outputIndex < shapedStitches.length; outputIndex += 1) {
-    const stitch = shapedStitches[outputIndex];
-    if (!stitch.isShaping || stitch.operationIndex === void 0 || stitch.shapingType === void 0) {
-      continue;
-    }
-    const existing = groups.get(stitch.operationIndex);
-    if (existing) {
-      if (existing.shapingType !== stitch.shapingType) {
-        throw new Error("Shaping operation contains mixed shaping types.");
-      }
-      existing.stitches.push(stitch);
-      existing.outputIndices.push(outputIndex);
-      existing.sourceIndices.push(stitch.sourceIndex);
-      continue;
-    }
-    groups.set(stitch.operationIndex, {
-      operationIndex: stitch.operationIndex,
-      outputIndices: [outputIndex],
-      shapingType: stitch.shapingType,
-      sourceIndices: [stitch.sourceIndex],
-      stitches: [stitch]
-    });
-  }
-  return Array.from(groups.values());
-}
-
 // src/shaping/shapingDsl.ts
 var SHAPING_CLAUSE_RE = /^(?:shape|shaping)\s*:?\s*(increase|decrease)\s+(\d+)$/i;
 var TOTAL_CLAUSE_RE = /^(?:total|total-stitches|stitches)\s*:?\s*(\d+)$/i;
@@ -2405,8 +2473,8 @@ function resolveShapingDslAst(ast) {
 function parseShapingDsl(input) {
   return resolveShapingDslAst(parseShapingDslAst(input));
 }
-function compileShapingDsl(input) {
-  return shapeRow(parseShapingDsl(input));
+function compileShapingDsl(input, alignment) {
+  return shapeRow({ ...parseShapingDsl(input), alignment });
 }
 
 // src/shaping/shapingDebug.ts
@@ -2461,11 +2529,11 @@ function renderShapingDebugForInput(input, options = {}) {
 function printShapingDebug(shapedStitches, label, options = {}) {
   const { legend, markers, row } = renderShapingDebug(shapedStitches, options);
   if (label) {
-    debugLogger == null ? void 0 : debugLogger.log(label);
+    debugLogger?.log(label);
   }
-  debugLogger == null ? void 0 : debugLogger.log(row);
-  debugLogger == null ? void 0 : debugLogger.log(markers);
-  debugLogger == null ? void 0 : debugLogger.log(legend);
+  debugLogger?.log(row);
+  debugLogger?.log(markers);
+  debugLogger?.log(legend);
 }
 
 // src/public/shaping.ts
@@ -2508,6 +2576,13 @@ function compileShapingDsl2(input) {
     throw wrapExpansionError3(error, "compileShapingDsl");
   }
 }
+function compileRow2(input) {
+  try {
+    return compileRow(input);
+  } catch (error) {
+    throw wrapExpansionError3(error, "compileRow");
+  }
+}
 function shapeRow2(input) {
   try {
     return shapeRow(input);
@@ -2537,6 +2612,7 @@ export {
   cmToStitches,
   compileCompatibleRowDsl2 as compileCompatibleRowDsl,
   compilePattern2 as compilePattern,
+  compileRow2 as compileRow,
   compileRowDsl2 as compileRowDsl,
   compileShapingDsl2 as compileShapingDsl,
   convertLength,
@@ -2551,7 +2627,7 @@ export {
   expandRowToStitches,
   groupShapedStitchesByOperation2 as groupShapedStitchesByOperation,
   isRowDslAstWellFormed,
-  normaliseMeasurement,
+  normaliseMeasurement2 as normaliseMeasurement,
   parseCompatibleRowDsl2 as parseCompatibleRowDsl,
   parseCompatibleRowDslAst2 as parseCompatibleRowDslAst,
   parseRowDsl2 as parseRowDsl,
@@ -2563,10 +2639,10 @@ export {
   renderShapingDebug,
   renderShapingDebugForInput,
   resolveRowDslAst2 as resolveRowDslAst,
-  roundStitches,
+  roundStitches2 as roundStitches,
   rowToRowDsl2 as rowToRowDsl,
   rowsPerCm,
   shapeRow2 as shapeRow,
   shapedExpandPattern2 as shapedExpandPattern,
-  stitchesPerCm
+  stitchesPerCm2 as stitchesPerCm
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knitting-tools/core",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Knitting maths, row parsing, shaping, and pattern compilation utilities.",
   "private": false,
   "type": "module",
@@ -36,19 +36,21 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "test": "vitest run",
-    "typecheck": "tsc -p tsconfig.src.json --noEmit",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "check": "pnpm build && pnpm typecheck && pnpm test:coverage",
-    "prepack": "pnpm build"
+  "dependencies": {
+    "@knitting-tools/math": "3.0.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.1.0",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.src.json --noEmit",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "check": "pnpm build && pnpm typecheck && pnpm test:coverage"
   }
-}
+}