@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/scripts/workspace-lint.js

@@ -1,15 +0,0 @@
-import { packageScriptPath } from '../operations/services/runtime-tools.js';
-import { packagesWithScript, run, workspaceRoot } from '../operations/services/workspace-tools.js';
-const root = workspaceRoot();
-process.stderr.write('[workspace-lint] markdown cleanup check start\n');
-const markdownStartedAt = Date.now();
-run(process.execPath, [packageScriptPath('cleanup-markdown'), '--check'], {
-    cwd: root,
-});
-process.stderr.write(`[workspace-lint] markdown cleanup check complete after ${((Date.now() - markdownStartedAt) / 1000).toFixed(1)}s\n`);
-for (const pkg of packagesWithScript('lint', root)) {
-    const startedAt = Date.now();
-    process.stderr.write(`[workspace-lint] ${pkg.name ?? pkg.dir} lint start\n`);
-    run('npm', ['run', 'lint'], { cwd: pkg.dir });
-    process.stderr.write(`[workspace-lint] ${pkg.name ?? pkg.dir} lint complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
-}

package/dist/scripts/workspace-preflight.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from 'node:path';
-import { collectCliPreflight, formatCliPreflightReport, writeJsonArtifact } from '../operations/services/workspace-preflight.js';
-const args = new Set(process.argv.slice(2));
-const requireAuth = args.has('--require-auth');
-const json = args.has('--json');
-const reportPathArgIndex = process.argv.indexOf('--report-path');
-const reportPath = reportPathArgIndex >= 0 ? process.argv[reportPathArgIndex + 1] : process.env.TREESEED_PREFLIGHT_REPORT_PATH;
-const report = collectCliPreflight({
-    cwd: process.cwd(),
-    requireAuth,
-});
-if (reportPath) {
-    writeJsonArtifact(resolve(reportPath), report);
-}
-if (json) {
-    console.log(JSON.stringify(report, null, 2));
-}
-else {
-    console.log(formatCliPreflightReport(report));
-}
-process.exit(report.ok ? 0 : 1);

package/dist/scripts/workspace-publish-changed-packages.js

@@ -1,16 +0,0 @@
-import { packageScriptPath } from '../operations/services/runtime-tools.js';
-import { publishableWorkspacePackages, changedWorkspacePackages, run } from '../operations/services/workspace-tools.js';
-const publishablePackages = publishableWorkspacePackages();
-const changed = changedWorkspacePackages({ packages: publishablePackages, includeDependents: true });
-if (changed.length === 0) {
-    console.log('No changed workspace packages to publish.');
-    process.exit(0);
-}
-console.log(`Publishing changed workspace packages in order: ${changed.map((pkg) => pkg.name).join(', ')}`);
-run(process.execPath, [packageScriptPath('workspace-release-verify'), '--changed', '--full-smoke']);
-for (const pkg of changed) {
-    console.log(`Publishing ${pkg.name}`);
-    run('npm', ['run', 'release:publish'], {
-        cwd: pkg.dir,
-    });
-}

package/dist/scripts/workspace-release-test.js

@@ -1,104 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { resolve } from 'node:path';
-import { sortWorkspacePackages, workspacePackages, workspaceRoot, run } from '../operations/services/workspace-tools.js';
-const packages = sortWorkspacePackages(workspacePackages());
-const root = workspaceRoot();
-function readProcessCommand(pid) {
-    try {
-        return readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ').trim()
-            || readFileSync(`/proc/${pid}/comm`, 'utf8').trim();
-    }
-    catch {
-        return '';
-    }
-}
-function processFdCount(pid) {
-    try {
-        return readdirSync(`/proc/${pid}/fd`).length;
-    }
-    catch {
-        return null;
-    }
-}
-function runningProcesses() {
-    if (!existsSync('/proc')) {
-        return [];
-    }
-    return readdirSync('/proc')
-        .filter((entry) => /^\d+$/u.test(entry))
-        .map((pid) => ({
-        pid: Number(pid),
-        fdCount: processFdCount(pid),
-        command: readProcessCommand(pid),
-    }))
-        .filter((entry) => entry.command.length > 0);
-}
-function terminate(pid, signal) {
-    try {
-        process.kill(pid, signal);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function cleanupStaleWorkspaceVerificationProcesses() {
-    const normalizedRoot = resolve(root);
-    const stale = runningProcesses().filter((entry) => {
-        const command = entry.command;
-        if (!command.includes('/.treeseed/worktrees/') || command.includes(normalizedRoot)) {
-            return false;
-        }
-        return /(vitest|release-verify|src\/verification\.ts|workspace-release-test)/u.test(command);
-    });
-    if (stale.length === 0) {
-        return;
-    }
-    process.stderr.write(`[workspace-release-test] stopping ${stale.length} stale sibling worktree verification process(es) before release tests\n`);
-    for (const entry of stale) {
-        process.stderr.write(`[workspace-release-test] SIGTERM stale pid ${entry.pid}: ${entry.command.slice(0, 180)}\n`);
-        terminate(entry.pid, 'SIGTERM');
-    }
-    spawnSync(process.execPath, ['-e', 'setTimeout(() => {}, 1000)'], { stdio: 'ignore' });
-    for (const entry of stale) {
-        try {
-            process.kill(entry.pid, 0);
-            process.stderr.write(`[workspace-release-test] SIGKILL stale pid ${entry.pid}: ${entry.command.slice(0, 180)}\n`);
-            terminate(entry.pid, 'SIGKILL');
-        }
-        catch {
-            // Process exited after SIGTERM.
-        }
-    }
-}
-function writeFdDiagnostic(label) {
-    const rows = runningProcesses()
-        .filter((entry) => (entry.fdCount ?? 0) >= 80)
-        .sort((left, right) => (right.fdCount ?? 0) - (left.fdCount ?? 0))
-        .slice(0, 10);
-    if (rows.length === 0) {
-        process.stderr.write(`[workspace-release-test] fd ${label}: no process with >=80 open descriptors\n`);
-        return;
-    }
-    process.stderr.write(`[workspace-release-test] fd ${label}: ${rows.map((entry) => `${entry.pid}:${entry.fdCount}:${entry.command.slice(0, 80)}`).join(' | ')}\n`);
-}
-cleanupStaleWorkspaceVerificationProcesses();
-writeFdDiagnostic('before');
-for (const pkg of packages) {
-    const scripts = pkg.packageJson.scripts ?? {};
-    const scriptName = typeof scripts['test:release'] === 'string'
-        ? 'test:release'
-        : typeof scripts['test:unit'] === 'string'
-            ? 'test:unit'
-            : typeof scripts.test === 'string'
-                ? 'test'
-                : null;
-    if (scriptName) {
-        const startedAt = Date.now();
-        process.stderr.write(`[workspace-release-test] ${pkg.name ?? pkg.dir} ${scriptName} start\n`);
-        run('npm', ['run', scriptName], { cwd: pkg.dir });
-        process.stderr.write(`[workspace-release-test] ${pkg.name ?? pkg.dir} ${scriptName} complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
-        writeFdDiagnostic(`after ${pkg.name ?? pkg.dir}`);
-    }
-}

package/dist/scripts/workspace-release-verify.js

@@ -1,81 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { publishableWorkspacePackages, changedWorkspacePackages, } from '../operations/services/workspace-tools.js';
-const cliArgs = new Set(process.argv.slice(2));
-const verifyChangedOnly = cliArgs.has('--changed');
-const fullSmoke = cliArgs.has('--full-smoke') || process.env.TREESEED_RELEASE_FULL_SMOKE === '1';
-const publishablePackages = publishableWorkspacePackages();
-const packagesToVerify = verifyChangedOnly
-    ? changedWorkspacePackages({ packages: publishablePackages, includeDependents: true })
-    : publishablePackages;
-const timings = [];
-function nowLabel() {
-    return new Date().toISOString();
-}
-function logStep(message) {
-    console.log(`[release-verify ${nowLabel()}] ${message}`);
-}
-async function withTiming(label, action) {
-    const startedAt = Date.now();
-    logStep(`${label} started`);
-    try {
-        await action();
-        const durationMs = Date.now() - startedAt;
-        timings.push({ label, durationMs, status: 'completed' });
-        logStep(`${label} completed in ${(durationMs / 1000).toFixed(1)}s`);
-    }
-    catch (error) {
-        const durationMs = Date.now() - startedAt;
-        timings.push({ label, durationMs, status: 'failed' });
-        logStep(`${label} failed in ${(durationMs / 1000).toFixed(1)}s`);
-        throw error;
-    }
-}
-function printSummary() {
-    if (timings.length === 0) {
-        return;
-    }
-    console.log('[release-verify] Stage summary');
-    for (const entry of timings) {
-        console.log(`[release-verify] ${entry.status === 'completed' ? 'ok  ' : 'fail'} ${entry.label} (${(entry.durationMs / 1000).toFixed(1)}s)`);
-    }
-}
-function verifyManifest(pkg) {
-    for (const [dep, value] of Object.entries(pkg.packageJson.dependencies ?? {})) {
-        if (!dep.startsWith('@treeseed/')) {
-            continue;
-        }
-        if (String(value).startsWith('file:') || String(value).startsWith('workspace:')) {
-            throw new Error(`${pkg.name} dependency ${dep} must not use local-only specifier "${value}".`);
-        }
-    }
-}
-function runPackageVerify(pkg) {
-    const extraArgs = fullSmoke ? ['--', '--full-smoke'] : [];
-    const result = spawnSync('npm', ['run', 'verify', ...extraArgs], {
-        cwd: pkg.dir,
-        stdio: 'inherit',
-        env: process.env,
-    });
-    if (result.status !== 0) {
-        throw new Error(`${pkg.name} verify failed`);
-    }
-}
-if (packagesToVerify.length === 0) {
-    console.log('No changed workspace packages to verify.');
-    process.exit(0);
-}
-try {
-    logStep(`verifying ${packagesToVerify.map((pkg) => pkg.name).join(', ')} with package-owned ${fullSmoke ? 'full' : 'fast'} verification`);
-    for (const pkg of packagesToVerify) {
-        await withTiming(`${pkg.name} manifest verification`, async () => {
-            verifyManifest(pkg);
-        });
-        await withTiming(`${pkg.name} verify`, async () => {
-            runPackageVerify(pkg);
-        });
-    }
-    console.log(`Release verification passed for: ${packagesToVerify.map((pkg) => pkg.name).join(', ')}`);
-}
-finally {
-    printSummary();
-}

package/dist/scripts/workspace-save.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { TreeseedWorkflowError, TreeseedWorkflowSdk } from '../workflow.js';
-import { formatWorkspaceSaveFailureReport, formatWorkspaceSaveSuccessReport, parseWorkspaceSaveScriptArgs, } from '../operations/services/workspace-save-script.js';
-function writeSaveReport(payload) {
-    const target = process.env.TREESEED_SAVE_REPORT_PATH;
-    if (!target) {
-        return;
-    }
-    const filePath = resolve(target);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-}
-function printSaveSummary(payload) {
-    const commitSha = typeof payload.commitSha === 'string' ? payload.commitSha : '';
-    const previewStatus = typeof payload.previewAction?.status === 'string'
-        ? String(payload.previewAction.status)
-        : 'skipped';
-    if (payload.noChanges === true) {
-        console.log('Treeseed save found no new changes and confirmed branch sync.');
-    }
-    else {
-        console.log('Treeseed save completed successfully.');
-    }
-    if (typeof payload.branch === 'string') {
-        console.log(`Branch: ${payload.branch}`);
-    }
-    if (typeof payload.scope === 'string') {
-        console.log(`Environment scope: ${payload.scope}`);
-    }
-    if (commitSha) {
-        console.log(`Commit: ${commitSha.slice(0, 12)}`);
-    }
-    console.log(`Preview action: ${previewStatus}`);
-}
-async function main() {
-    const options = parseWorkspaceSaveScriptArgs(process.argv.slice(2));
-    const workflow = new TreeseedWorkflowSdk({
-        cwd: process.cwd(),
-        env: process.env,
-    });
-    try {
-        const result = await workflow.save({
-            message: options.message,
-            hotfix: options.hotfix,
-        });
-        const payload = result.payload;
-        writeSaveReport(formatWorkspaceSaveSuccessReport(result));
-        printSaveSummary(payload);
-    }
-    catch (error) {
-        if (error instanceof TreeseedWorkflowError) {
-            writeSaveReport(formatWorkspaceSaveFailureReport(error));
-            console.error(error.message);
-            process.exit(error.exitCode ?? 1);
-        }
-        const report = formatWorkspaceSaveFailureReport(error);
-        console.error(report.message);
-        writeSaveReport(report);
-        process.exit(1);
-    }
-}
-await main();

package/dist/scripts/workspace-start-warning.js

@@ -1,3 +0,0 @@
-console.error('`npm run start` is deprecated.');
-console.error('Use `treeseed dev` for local development or `treeseed switch <branch-name>` for recursive task branch creation.');
-process.exit(1);

package/dist/scripts/workspace-test-unit.js

@@ -1,4 +0,0 @@
-import { packagesWithScript, run } from '../operations/services/workspace-tools.js';
-for (const pkg of packagesWithScript('test:unit')) {
-    run('npm', ['run', 'test:unit'], { cwd: pkg.dir });
-}

package/dist/scripts/workspace-test.js

@@ -1,17 +0,0 @@
-import { sortWorkspacePackages, workspacePackages, run } from '../operations/services/workspace-tools.js';
-const packages = sortWorkspacePackages(workspacePackages());
-for (const pkg of packages) {
-    if (typeof pkg.packageJson.scripts?.['test:unit'] === 'string') {
-        const startedAt = Date.now();
-        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test:unit start\n`);
-        run('npm', ['run', 'test:unit'], { cwd: pkg.dir });
-        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test:unit complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
-        continue;
-    }
-    if (typeof pkg.packageJson.scripts?.test === 'string') {
-        const startedAt = Date.now();
-        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test start\n`);
-        run('npm', ['run', 'test'], { cwd: pkg.dir });
-        process.stderr.write(`[workspace-test] ${pkg.name ?? pkg.dir} test complete after ${((Date.now() - startedAt) / 1000).toFixed(1)}s\n`);
-    }
-}

package/dist/sdk-dispatch.d.ts

@@ -1,12 +0,0 @@
-import type { AgentSdk } from './sdk.js';
-type JsonRecord = Record<string, unknown>;
-type SdkOperationHandler = (sdk: AgentSdk, input: JsonRecord) => Promise<unknown> | unknown;
-interface SdkOperationSpec {
-    name: string;
-    aliases?: string[];
-    handler: SdkOperationHandler;
-}
-export declare function listSdkOperationNames(): string[];
-export declare function findSdkOperation(name: string): SdkOperationSpec | null;
-export declare function executeSdkOperation(sdk: AgentSdk, operationName: string, input: JsonRecord): Promise<unknown>;
-export {};

package/dist/sdk-dispatch.js

@@ -1,126 +0,0 @@
-function passthrough(methodName) {
-  return (sdk, input) => sdk[methodName](input);
-}
-const SDK_OPERATION_SPECS = [
-  { name: "get", handler: passthrough("get") },
-  { name: "read", handler: passthrough("read") },
-  { name: "search", handler: passthrough("search") },
-  { name: "follow", handler: passthrough("follow") },
-  { name: "pick", handler: passthrough("pick") },
-  { name: "create", handler: passthrough("create") },
-  { name: "update", handler: passthrough("update") },
-  { name: "claimMessage", aliases: ["claim-message"], handler: passthrough("claimMessage") },
-  { name: "ackMessage", aliases: ["ack-message"], handler: passthrough("ackMessage") },
-  { name: "createMessage", aliases: ["create-message"], handler: passthrough("createMessage") },
-  { name: "recordRun", aliases: ["record-run"], handler: passthrough("recordRun") },
-  { name: "getCursor", aliases: ["get-cursor"], handler: passthrough("getCursor") },
-  { name: "upsertCursor", aliases: ["upsert-cursor"], handler: passthrough("upsertCursor") },
-  { name: "releaseLease", aliases: ["release-lease"], handler: passthrough("releaseLease") },
-  {
-    name: "releaseAllLeases",
-    aliases: ["release-all-leases"],
-    handler: (sdk) => sdk.releaseAllLeases()
-  },
-  { name: "startWorkDay", aliases: ["start-work-day"], handler: passthrough("startWorkDay") },
-  { name: "closeWorkDay", aliases: ["close-work-day"], handler: passthrough("closeWorkDay") },
-  { name: "createReport", aliases: ["create-report"], handler: passthrough("createReport") },
-  {
-    name: "listAgentSpecs",
-    aliases: ["list-agent-specs"],
-    handler: (sdk, input) => sdk.listAgentSpecs(input)
-  },
-  {
-    name: "listRawAgentSpecs",
-    aliases: ["list-raw-agent-specs"],
-    handler: (sdk, input) => sdk.listRawAgentSpecs(input)
-  },
-  { name: "refreshGraph", aliases: ["refresh-graph"], handler: passthrough("refreshGraph") },
-  {
-    name: "searchFiles",
-    aliases: ["search-files"],
-    handler: (sdk, input) => sdk.searchFiles(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "searchSections",
-    aliases: ["search-sections"],
-    handler: (sdk, input) => sdk.searchSections(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "searchEntities",
-    aliases: ["search-entities"],
-    handler: (sdk, input) => sdk.searchEntities(String(input.query ?? ""), input.options)
-  },
-  {
-    name: "getGraphNode",
-    aliases: ["get-graph-node"],
-    handler: (sdk, input) => sdk.getGraphNode(String(input.id ?? ""))
-  },
-  {
-    name: "getNeighbors",
-    aliases: ["get-neighbors"],
-    handler: (sdk, input) => sdk.getNeighbors(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "followReferences",
-    aliases: ["follow-references"],
-    handler: (sdk, input) => sdk.followReferences(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getBacklinks",
-    aliases: ["get-backlinks"],
-    handler: (sdk, input) => sdk.getBacklinks(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getRelated",
-    aliases: ["get-related"],
-    handler: (sdk, input) => sdk.getRelated(String(input.id ?? ""), input.options)
-  },
-  {
-    name: "getSubgraph",
-    aliases: ["get-subgraph"],
-    handler: (sdk, input) => sdk.getSubgraph(Array.isArray(input.seedIds) ? input.seedIds.map(String) : [], input.options)
-  },
-  { name: "resolveSeeds", aliases: ["resolve-seeds"], handler: passthrough("resolveSeeds") },
-  { name: "queryGraph", aliases: ["query-graph"], handler: passthrough("queryGraph") },
-  { name: "buildContextPack", aliases: ["build-context-pack"], handler: passthrough("buildContextPack") },
-  {
-    name: "parseGraphDsl",
-    aliases: ["parse-graph-dsl"],
-    handler: (sdk, input) => sdk.parseGraphDsl(String(input.source ?? input.query ?? ""))
-  },
-  {
-    name: "resolveReference",
-    aliases: ["resolve-reference"],
-    handler: (sdk, input) => sdk.resolveReference(String(input.reference ?? ""), input.options)
-  },
-  {
-    name: "explainReferenceChain",
-    aliases: ["explain-reference-chain"],
-    handler: (sdk, input) => sdk.explainReferenceChain(String(input.fromId ?? ""), String(input.toId ?? ""))
-  }
-];
-const SDK_OPERATION_INDEX = /* @__PURE__ */ new Map();
-for (const spec of SDK_OPERATION_SPECS) {
-  SDK_OPERATION_INDEX.set(spec.name, spec);
-  for (const alias of spec.aliases ?? []) {
-    SDK_OPERATION_INDEX.set(alias, spec);
-  }
-}
-function listSdkOperationNames() {
-  return [...new Set(SDK_OPERATION_SPECS.map((entry) => entry.name))];
-}
-function findSdkOperation(name) {
-  return SDK_OPERATION_INDEX.get(name) ?? null;
-}
-async function executeSdkOperation(sdk, operationName, input) {
-  const spec = findSdkOperation(operationName);
-  if (!spec) {
-    throw new Error(`Unknown SDK operation "${operationName}".`);
-  }
-  return await spec.handler(sdk, input);
-}
-export {
-  executeSdkOperation,
-  findSdkOperation,
-  listSdkOperationNames
-};

package/dist/sdk-fields.d.ts

@@ -1,11 +0,0 @@
-import type { SdkModelDefinition, SdkModelFieldBinding, SdkSortSpec, SdkFilterCondition } from './sdk-types.js';
-export declare function validateModelFieldAliases(definition: SdkModelDefinition): void;
-export declare function resolveModelField(definition: SdkModelDefinition, requestedField: string): SdkModelFieldBinding;
-export declare function readCanonicalFieldValue(definition: SdkModelDefinition, record: Record<string, unknown>, canonicalField: string): unknown;
-export declare function normalizeRecordToCanonicalShape(definition: SdkModelDefinition, record: Record<string, unknown>): Record<string, unknown>;
-export declare function normalizeMutationData(definition: SdkModelDefinition, data: Record<string, unknown>): Record<string, unknown>;
-export declare function canonicalizeFrontmatter(definition: SdkModelDefinition, frontmatter: Record<string, unknown>, updates?: Record<string, unknown>): {
-    [x: string]: unknown;
-};
-export declare function normalizeFilterFields(definition: SdkModelDefinition, filters?: SdkFilterCondition[]): SdkFilterCondition[];
-export declare function normalizeSortFields(definition: SdkModelDefinition, sort?: SdkSortSpec[]): SdkSortSpec[];

package/dist/sdk-filters.d.ts

@@ -1,4 +0,0 @@
-import type { SdkContentEntry, SdkFilterCondition, SdkModelDefinition, SdkSortSpec } from './sdk-types.js';
-export declare function matchesFilter(entry: SdkContentEntry | Record<string, unknown>, filter: SdkFilterCondition, definition?: SdkModelDefinition): boolean;
-export declare function applyFilters<T extends SdkContentEntry | Record<string, unknown>>(items: T[], filters?: SdkFilterCondition[], definition?: SdkModelDefinition): T[];
-export declare function applySort<T extends SdkContentEntry | Record<string, unknown>>(items: T[], sort?: SdkSortSpec[], definition?: SdkModelDefinition): T[];

package/dist/sdk-filters.js

@@ -1,74 +0,0 @@
-import { readCanonicalFieldValue } from "./sdk-fields.js";
-function toArray(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (value === void 0 || value === null) {
-    return [];
-  }
-  return [value];
-}
-function compareScalar(left, right) {
-  if (typeof left === "number" && typeof right === "number") {
-    return left - right;
-  }
-  if (left instanceof Date || right instanceof Date) {
-    return new Date(String(left ?? 0)).valueOf() - new Date(String(right ?? 0)).valueOf();
-  }
-  return String(left ?? "").localeCompare(String(right ?? ""));
-}
-function matchesFilter(entry, filter, definition) {
-  const fieldValue = definition ? readCanonicalFieldValue(definition, entry, filter.field) : entry[filter.field];
-  switch (filter.op) {
-    case "eq":
-      return fieldValue === filter.value;
-    case "in":
-      return toArray(filter.value).includes(fieldValue);
-    case "contains":
-      if (Array.isArray(fieldValue)) {
-        return fieldValue.includes(filter.value);
-      }
-      return String(fieldValue ?? "").toLowerCase().includes(String(filter.value ?? "").toLowerCase());
-    case "prefix":
-      return String(fieldValue ?? "").toLowerCase().startsWith(String(filter.value ?? "").toLowerCase());
-    case "gt":
-      return compareScalar(fieldValue, filter.value) > 0;
-    case "gte":
-      return compareScalar(fieldValue, filter.value) >= 0;
-    case "lt":
-      return compareScalar(fieldValue, filter.value) < 0;
-    case "lte":
-      return compareScalar(fieldValue, filter.value) <= 0;
-    case "updated_since":
-      return new Date(String(fieldValue ?? 0)).valueOf() >= new Date(String(filter.value)).valueOf();
-    case "related_to":
-      return Array.isArray(fieldValue) && fieldValue.includes(filter.value);
-    default:
-      return false;
-  }
-}
-function applyFilters(items, filters = [], definition) {
-  return items.filter((item) => filters.every((filter) => matchesFilter(item, filter, definition)));
-}
-function applySort(items, sort = [], definition) {
-  if (sort.length === 0) {
-    return items;
-  }
-  return [...items].sort((left, right) => {
-    for (const spec of sort) {
-      const direction = spec.direction === "asc" ? 1 : -1;
-      const leftValue = definition ? readCanonicalFieldValue(definition, left, spec.field) : left[spec.field];
-      const rightValue = definition ? readCanonicalFieldValue(definition, right, spec.field) : right[spec.field];
-      const comparison = compareScalar(leftValue, rightValue);
-      if (comparison !== 0) {
-        return comparison * direction;
-      }
-    }
-    return 0;
-  });
-}
-export {
-  applyFilters,
-  applySort,
-  matchesFilter
-};