@ontrails/core 1.0.0-beta.14 → 1.0.0-beta.16

package/src/__tests__/blob-ref.test.ts

@@ -1,103 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { createBlobRef, isBlobRef } from '../blob-ref';
-
-describe('BlobRef', () => {
-  const sampleData = new Uint8Array([137, 80, 78, 71]);
-
-  describe('createBlobRef', () => {
-    test('returns a frozen object with the provided fields', () => {
-      const ref = createBlobRef({
-        data: sampleData,
-        mimeType: 'image/png',
-        name: 'image.png',
-        size: 4,
-      });
-
-      expect(ref.name).toBe('image.png');
-      expect(ref.mimeType).toBe('image/png');
-      expect(ref.size).toBe(4);
-      expect(ref.data).toBe(sampleData);
-      expect(Object.isFrozen(ref)).toBe(true);
-    });
-
-    test('works with ReadableStream data', () => {
-      const stream = new ReadableStream<Uint8Array>({
-        start(controller) {
-          controller.enqueue(sampleData);
-          controller.close();
-        },
-      });
-
-      const ref = createBlobRef({
-        data: stream,
-        mimeType: 'video/mp4',
-        name: 'video.mp4',
-        size: 1024,
-      });
-
-      expect(ref.data).toBeInstanceOf(ReadableStream);
-    });
-  });
-
-  describe('isBlobRef', () => {
-    test('returns true for a valid BlobRef with Uint8Array data', () => {
-      const ref = createBlobRef({
-        data: sampleData,
-        mimeType: 'application/octet-stream',
-        name: 'file.bin',
-        size: 4,
-      });
-
-      expect(isBlobRef(ref)).toBe(true);
-    });
-
-    test('returns true for a valid BlobRef with ReadableStream data', () => {
-      const stream = new ReadableStream<Uint8Array>();
-      const ref = createBlobRef({
-        data: stream,
-        mimeType: 'application/octet-stream',
-        name: 'file.bin',
-        size: 0,
-      });
-
-      expect(isBlobRef(ref)).toBe(true);
-    });
-
-    test('returns true for a plain object matching the shape', () => {
-      expect(
-        isBlobRef({
-          data: new Uint8Array(),
-          mimeType: 'application/pdf',
-          name: 'doc.pdf',
-          size: 999,
-        })
-      ).toBe(true);
-    });
-
-    test('returns false for null', () => {
-      expect(isBlobRef(null)).toBe(false);
-    });
-
-    test('returns false for a string', () => {
-      expect(isBlobRef('not a blob')).toBe(false);
-    });
-
-    test('returns false when name is missing', () => {
-      expect(
-        isBlobRef({ data: new Uint8Array(), mimeType: 'text/plain', size: 0 })
-      ).toBe(false);
-    });
-
-    test('returns false when data is a plain object', () => {
-      expect(
-        isBlobRef({
-          data: {},
-          mimeType: 'text/plain',
-          name: 'x',
-          size: 0,
-        })
-      ).toBe(false);
-    });
-  });
-});

package/src/__tests__/branded.test.ts

@@ -1,148 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  brand,
-  unbrand,
-  uuid,
-  email,
-  nonEmptyString,
-  positiveInt,
-  shortId,
-  hashId,
-} from '../branded';
-
-describe('branded', () => {
-  describe('brand / unbrand', () => {
-    test('brand wraps and unbrand unwraps', () => {
-      const branded = brand('Tag', 'hello');
-      expect(unbrand(branded)).toBe('hello');
-    });
-
-    test('branded value is still usable as base type at runtime', () => {
-      const branded = brand('PositiveInt', 42);
-      expect(branded + 1).toBe(43);
-    });
-  });
-
-  describe('uuid()', () => {
-    test('accepts a valid v4 UUID', () => {
-      const result = uuid('550e8400-e29b-41d4-a716-446655440000');
-      expect(result.isOk()).toBe(true);
-      const value: string = unbrand(result.unwrap());
-      expect(value).toBe('550e8400-e29b-41d4-a716-446655440000');
-    });
-
-    test('rejects an empty string', () => {
-      const result = uuid('');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects a malformed UUID', () => {
-      const result = uuid('not-a-uuid');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects UUID missing hyphens', () => {
-      const result = uuid('550e8400e29b41d4a716446655440000');
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('email()', () => {
-    test('accepts a simple email', () => {
-      const result = email('test@example.com');
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('rejects missing @', () => {
-      const result = email('testexample.com');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects missing domain', () => {
-      const result = email('test@');
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects empty string', () => {
-      const result = email('');
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('nonEmptyString()', () => {
-    test('accepts a non-empty string', () => {
-      const result = nonEmptyString('hello');
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('rejects an empty string', () => {
-      const result = nonEmptyString('');
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('positiveInt()', () => {
-    test('accepts 1', () => {
-      const result = positiveInt(1);
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('accepts a large integer', () => {
-      const result = positiveInt(1_000_000);
-      expect(result.isOk()).toBe(true);
-    });
-
-    test('rejects 0', () => {
-      const result = positiveInt(0);
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects negative numbers', () => {
-      const result = positiveInt(-5);
-      expect(result.isErr()).toBe(true);
-    });
-
-    test('rejects non-integers', () => {
-      const result = positiveInt(1.5);
-      expect(result.isErr()).toBe(true);
-    });
-  });
-
-  describe('shortId()', () => {
-    test('returns a string of default length 8', () => {
-      const id = shortId();
-      expect(id).toHaveLength(8);
-    });
-
-    test('respects custom length', () => {
-      const id = shortId(16);
-      expect(id).toHaveLength(16);
-    });
-
-    test('contains only alphanumeric characters', () => {
-      const id = shortId(100);
-      expect(id).toMatch(/^[A-Za-z0-9]+$/);
-    });
-
-    test('produces unique values', () => {
-      const ids = new Set(Array.from({ length: 50 }, () => shortId()));
-      expect(ids.size).toBe(50);
-    });
-  });
-
-  describe('hashId()', () => {
-    test('returns a hex string', () => {
-      const id = hashId('test');
-      expect(id).toMatch(/^[0-9a-f]{8}$/);
-    });
-
-    test('is deterministic', () => {
-      expect(hashId('hello')).toBe(hashId('hello'));
-    });
-
-    test('different inputs produce different outputs', () => {
-      expect(hashId('a')).not.toBe(hashId('b'));
-    });
-  });
-});

package/src/__tests__/collections.test.ts

@@ -1,126 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import {
-  chunk,
-  dedupe,
-  groupBy,
-  sortBy,
-  isNonEmptyArray,
-} from '../collections';
-
-describe('collections', () => {
-  describe('chunk()', () => {
-    test('splits into even chunks', () => {
-      expect(chunk([1, 2, 3, 4], 2)).toEqual([
-        [1, 2],
-        [3, 4],
-      ]);
-    });
-
-    test('handles remainder', () => {
-      expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
-    });
-
-    test('returns empty array for empty input', () => {
-      expect(chunk([], 3)).toEqual([]);
-    });
-
-    test('single-element chunks', () => {
-      expect(chunk([1, 2, 3], 1)).toEqual([[1], [2], [3]]);
-    });
-
-    test('chunk size larger than array', () => {
-      expect(chunk([1, 2], 10)).toEqual([[1, 2]]);
-    });
-
-    test('throws on size < 1', () => {
-      expect(() => chunk([1], 0)).toThrow(RangeError);
-    });
-  });
-
-  describe('dedupe()', () => {
-    test('removes primitive duplicates', () => {
-      expect(dedupe([1, 2, 2, 3, 1])).toEqual([1, 2, 3]);
-    });
-
-    test('dedupes by key function', () => {
-      const items = [
-        { id: 1, name: 'a' },
-        { id: 2, name: 'b' },
-        { id: 1, name: 'c' },
-      ];
-      const result = dedupe(items, (i) => i.id);
-      expect(result).toEqual([
-        { id: 1, name: 'a' },
-        { id: 2, name: 'b' },
-      ]);
-    });
-
-    test('preserves order', () => {
-      expect(dedupe([3, 1, 2, 1, 3])).toEqual([3, 1, 2]);
-    });
-
-    test('handles empty array', () => {
-      expect(dedupe([])).toEqual([]);
-    });
-  });
-
-  describe('groupBy()', () => {
-    test('groups by key', () => {
-      const items = [
-        { type: 'a', value: 1 },
-        { type: 'b', value: 2 },
-        { type: 'a', value: 3 },
-      ];
-      const groups = groupBy(items, (i) => i.type);
-      expect(groups).toEqual({
-        a: [
-          { type: 'a', value: 1 },
-          { type: 'a', value: 3 },
-        ],
-        b: [{ type: 'b', value: 2 }],
-      });
-    });
-
-    test('returns empty object for empty array', () => {
-      expect(groupBy([], () => 'key')).toEqual({});
-    });
-  });
-
-  describe('sortBy()', () => {
-    test('sorts by numeric key ascending', () => {
-      const items = [{ n: 3 }, { n: 1 }, { n: 2 }];
-      expect(sortBy(items, (i) => i.n)).toEqual([{ n: 1 }, { n: 2 }, { n: 3 }]);
-    });
-
-    test('sorts by string key alphabetically', () => {
-      const items = [{ name: 'charlie' }, { name: 'alice' }, { name: 'bob' }];
-      expect(sortBy(items, (i) => i.name)).toEqual([
-        { name: 'alice' },
-        { name: 'bob' },
-        { name: 'charlie' },
-      ]);
-    });
-
-    test('does not mutate the original array', () => {
-      const original = [{ n: 3 }, { n: 1 }];
-      sortBy(original, (i) => i.n);
-      expect(original[0]?.n).toBe(3);
-    });
-
-    test('returns empty array for empty input', () => {
-      expect(sortBy([], () => 0)).toEqual([]);
-    });
-  });
-
-  describe('isNonEmptyArray()', () => {
-    test('returns true for arrays with elements', () => {
-      expect(isNonEmptyArray([1])).toBe(true);
-      expect(isNonEmptyArray([1, 2, 3])).toBe(true);
-    });
-
-    test('returns false for empty array', () => {
-      expect(isNonEmptyArray([])).toBe(false);
-    });
-  });
-});

package/src/__tests__/context.test.ts

@@ -1,77 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { createTrailContext } from '../context.js';
-import type { TrailContext } from '../types.js';
-
-const UUID_RE =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-describe('createTrailContext', () => {
-  test('generates a requestId in UUID format', () => {
-    const ctx = createTrailContext();
-    expect(ctx.requestId).toMatch(UUID_RE);
-  });
-
-  test('defaults cwd to process.cwd()', () => {
-    const ctx = createTrailContext();
-    expect(ctx.cwd).toBe(process.cwd());
-  });
-
-  test('defaults env to process.env', () => {
-    const ctx = createTrailContext();
-    expect(ctx.env).toBeTruthy();
-    expect(ctx.env).toBe(process.env);
-  });
-
-  test('provides a non-aborted abortSignal by default', () => {
-    const ctx = createTrailContext();
-    expect(ctx.abortSignal).toBeInstanceOf(AbortSignal);
-    expect(ctx.abortSignal.aborted).toBe(false);
-  });
-
-  test('override values take precedence', () => {
-    const ac = new AbortController();
-    ac.abort();
-
-    const ctx = createTrailContext({
-      abortSignal: ac.signal,
-      cwd: '/custom/dir',
-      env: { CUSTOM: 'yes' },
-      requestId: 'custom-id',
-      workspaceRoot: '/tmp',
-    });
-
-    expect(ctx.cwd).toBe('/custom/dir');
-    expect(ctx.env).toEqual({ CUSTOM: 'yes' });
-    expect(ctx.requestId).toBe('custom-id');
-    expect(ctx.abortSignal.aborted).toBe(true);
-    expect(ctx.workspaceRoot).toBe('/tmp');
-  });
-
-  test('TrailContext supports extensions for custom fields', () => {
-    const ctx: TrailContext = createTrailContext({
-      extensions: { customField: 42, nested: { key: 'value' } },
-    });
-
-    expect(ctx.extensions?.['customField']).toBe(42);
-    expect(ctx.extensions?.['nested']).toEqual({ key: 'value' });
-  });
-
-  test('provides a provision accessor backed by extensions', () => {
-    const widget = { id: 'widget-1' };
-    const ctx = createTrailContext({
-      extensions: { 'widget.main': widget },
-    });
-
-    expect(ctx.provision('widget.main')).toBe(widget);
-    expect(ctx.provision<{ id: string }>({ id: 'widget.main' }).id).toBe(
-      'widget-1'
-    );
-  });
-
-  test('each call generates a unique requestId', () => {
-    const a = createTrailContext();
-    const b = createTrailContext();
-    expect(a.requestId).not.toBe(b.requestId);
-  });
-});

package/src/__tests__/derive.test.ts

@@ -1,260 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-
-import { z } from 'zod';
-
-import { deriveCliPath, deriveFields } from '../derive.js';
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('derive', () => {
-  describe('cli paths', () => {
-    test('top-level trail IDs derive to a one-segment CLI path', () => {
-      expect(deriveCliPath('search')).toEqual(['search']);
-    });
-
-    test('multi-dot trail IDs derive to the full ordered CLI path', () => {
-      expect(deriveCliPath('topo.pin.remove')).toEqual([
-        'topo',
-        'pin',
-        'remove',
-      ]);
-    });
-
-    test('trail IDs with consecutive dots throw a ValidationError', () => {
-      expect(() => deriveCliPath('topo..pin')).toThrow(
-        'Trail ID "topo..pin" contains an empty segment'
-      );
-    });
-
-    test('trail IDs with a leading dot throw a ValidationError', () => {
-      expect(() => deriveCliPath('.pin')).toThrow(
-        'Trail ID ".pin" contains an empty segment'
-      );
-    });
-
-    test('trail IDs with a trailing dot throw a ValidationError', () => {
-      expect(() => deriveCliPath('pin.')).toThrow(
-        'Trail ID "pin." contains an empty segment'
-      );
-    });
-  });
-
-  describe('primitive types', () => {
-    test('z.string() derives string field', () => {
-      const schema = z.object({ name: z.string() });
-      const fields = deriveFields(schema);
-      expect(fields).toHaveLength(1);
-      expect(fields[0]).toMatchObject({
-        label: 'Name',
-        name: 'name',
-        required: true,
-        type: 'string',
-      });
-    });
-
-    test('z.number() derives number field', () => {
-      const schema = z.object({ count: z.number() });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'count',
-        required: true,
-        type: 'number',
-      });
-    });
-
-    test('z.boolean() derives boolean field', () => {
-      const schema = z.object({ verbose: z.boolean() });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'verbose',
-        required: true,
-        type: 'boolean',
-      });
-    });
-  });
-
-  describe('enum and multiselect', () => {
-    test('z.enum() derives enum field with options', () => {
-      const schema = z.object({ color: z.enum(['red', 'green', 'blue']) });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'color',
-        required: true,
-        type: 'enum',
-      });
-      expect(fields[0]?.options).toEqual([
-        { value: 'red' },
-        { value: 'green' },
-        { value: 'blue' },
-      ]);
-    });
-
-    test('z.array(z.enum()) derives multiselect field', () => {
-      const schema = z.object({
-        tags: z.array(z.enum(['a', 'b', 'c'])),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'tags',
-        required: true,
-        type: 'multiselect',
-      });
-      expect(fields[0]?.options).toEqual([
-        { value: 'a' },
-        { value: 'b' },
-        { value: 'c' },
-      ]);
-    });
-  });
-
-  describe('array types', () => {
-    test('z.array(z.string()) derives string[] field', () => {
-      const schema = z.object({ names: z.array(z.string()) });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'names',
-        options: undefined,
-        required: true,
-        type: 'string[]',
-      });
-    });
-
-    test('z.array(z.number()) derives number[] field', () => {
-      const schema = z.object({ scores: z.array(z.number()) });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'scores',
-        options: undefined,
-        required: true,
-        type: 'number[]',
-      });
-    });
-
-    test('optional z.array(z.string()) marks not required', () => {
-      const schema = z.object({ tags: z.array(z.string()).optional() });
-      const fields = deriveFields(schema);
-      expect(fields[0]).toMatchObject({
-        name: 'tags',
-        required: false,
-        type: 'string[]',
-      });
-    });
-
-    test('z.array(z.string()) with default sets default value', () => {
-      const schema = z.object({
-        items: z.array(z.string()).default(['a', 'b']),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.required).toBe(false);
-      expect(fields[0]?.type).toBe('string[]');
-      expect(fields[0]?.default).toEqual(['a', 'b']);
-    });
-
-    test('z.array(z.object(...)) is omitted when it cannot be represented faithfully', () => {
-      const schema = z.object({
-        files: z.array(
-          z.object({
-            content: z.string(),
-            filename: z.string(),
-          })
-        ),
-      });
-
-      expect(deriveFields(schema)).toEqual([]);
-    });
-  });
-
-  describe('unsupported shapes', () => {
-    test('nested objects are omitted when they cannot be represented faithfully', () => {
-      const schema = z.object({
-        filter: z.object({
-          query: z.string(),
-        }),
-      });
-
-      expect(deriveFields(schema)).toEqual([]);
-    });
-  });
-
-  describe('modifiers', () => {
-    test('.describe() sets label', () => {
-      const schema = z.object({
-        name: z.string().describe('Your full name'),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.label).toBe('Your full name');
-    });
-
-    test('.default() sets default and marks not required', () => {
-      const schema = z.object({
-        port: z.number().default(3000),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.required).toBe(false);
-      expect(fields[0]?.default).toBe(3000);
-    });
-
-    test('.optional() marks not required', () => {
-      const schema = z.object({
-        nickname: z.string().optional(),
-      });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.required).toBe(false);
-    });
-  });
-
-  describe('overrides', () => {
-    test('override label replaces derived label', () => {
-      const schema = z.object({
-        name: z.string().describe('Derived label'),
-      });
-      const fields = deriveFields(schema, {
-        name: { label: 'Override label' },
-      });
-      expect(fields[0]?.label).toBe('Override label');
-    });
-
-    test('override options enrich enum values with labels and hints', () => {
-      const schema = z.object({
-        color: z.enum(['red', 'green', 'blue']),
-      });
-      const fields = deriveFields(schema, {
-        color: {
-          options: [
-            { hint: 'Hot color', label: 'Red', value: 'red' },
-            { label: 'Green', value: 'green' },
-          ],
-        },
-      });
-      expect(fields[0]?.options).toEqual([
-        { hint: 'Hot color', label: 'Red', value: 'red' },
-        { label: 'Green', value: 'green' },
-        { value: 'blue' },
-      ]);
-    });
-  });
-
-  describe('sorting and edge cases', () => {
-    test('returns fields sorted by name', () => {
-      const schema = z.object({
-        alpha: z.string(),
-        middle: z.string(),
-        zebra: z.string(),
-      });
-      const fields = deriveFields(schema);
-      expect(fields.map((f) => f.name)).toEqual(['alpha', 'middle', 'zebra']);
-    });
-
-    test('returns empty array for non-object schema', () => {
-      expect(deriveFields(z.string())).toEqual([]);
-    });
-
-    test('humanizes camelCase field names', () => {
-      const schema = z.object({ firstName: z.string() });
-      const fields = deriveFields(schema);
-      expect(fields[0]?.label).toBe('First Name');
-    });
-  });
-});