@treeseed/sdk 0.1.2 → 0.3.1

package/dist/scripts/workspace-lint.js

@@ -0,0 +1,9 @@
+import { packageScriptPath } from '../operations/services/runtime-tools.js';
+import { packagesWithScript, run, workspaceRoot } from '../operations/services/workspace-tools.js';
+const root = workspaceRoot();
+run(process.execPath, [packageScriptPath('cleanup-markdown'), '--check'], {
+    cwd: root,
+});
+for (const pkg of packagesWithScript('lint', root)) {
+    run('npm', ['run', 'lint'], { cwd: pkg.dir });
+}

package/dist/scripts/workspace-preflight.js

@@ -0,0 +1,22 @@
+#!/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

@@ -0,0 +1,16 @@
+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-verify.js

@@ -0,0 +1,81 @@
+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-release.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
+import { PRODUCTION_BRANCH, STAGING_BRANCH, mergeStagingIntoMain, prepareReleaseBranches, pushBranch } from '../operations/services/git-workflow.js';
+import { incrementVersion, planWorkspaceReleaseBump, applyWorkspaceVersionChanges, repoRoot } from '../operations/services/workspace-save.js';
+import { run, workspaceRoot } from '../operations/services/workspace-tools.js';
+import { runWorkspaceSavePreflight } from '../operations/services/save-deploy-preflight.js';
+function parseArgs(argv) {
+    const flags = new Set(argv);
+    const selected = ['major', 'minor', 'patch'].filter((level) => flags.has(`--${level}`));
+    if (selected.length !== 1) {
+        throw new Error('Treeseed release requires exactly one version bump flag: --major, --minor, or --patch.');
+    }
+    return { level: selected[0] };
+}
+function bumpRootPackageJson(root, level) {
+    const packageJsonPath = resolve(root, 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    packageJson.version = incrementVersion(packageJson.version, level);
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+    return packageJson.version;
+}
+const { level } = parseArgs(process.argv.slice(2));
+const root = workspaceRoot();
+const gitRoot = repoRoot(root);
+prepareReleaseBranches(root);
+applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope: 'staging', override: true });
+runWorkspaceSavePreflight({ cwd: root });
+const plan = planWorkspaceReleaseBump(level, root);
+applyWorkspaceVersionChanges(plan);
+const rootVersion = bumpRootPackageJson(root, level);
+run('git', ['checkout', STAGING_BRANCH], { cwd: gitRoot });
+run('git', ['add', '-A'], { cwd: gitRoot });
+run('git', ['commit', '-m', `release: ${level} bump`], { cwd: gitRoot });
+pushBranch(gitRoot, STAGING_BRANCH);
+mergeStagingIntoMain(root);
+console.log('Treeseed release completed successfully.');
+console.log(`Staging branch: ${STAGING_BRANCH}`);
+console.log(`Production branch: ${PRODUCTION_BRANCH}`);
+console.log(`Release level: ${level}`);
+console.log(`Root version: ${rootVersion}`);

package/dist/scripts/workspace-save.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
+import { collectMergeConflictReport, currentBranch, formatMergeConflictReport, hasMeaningfulChanges, originRemoteUrl, repoRoot, } from '../operations/services/workspace-save.js';
+import { remoteBranchExists, STAGING_BRANCH, PRODUCTION_BRANCH } from '../operations/services/git-workflow.js';
+import { run, workspaceRoot } from '../operations/services/workspace-tools.js';
+import { runWorkspaceSavePreflight } from '../operations/services/save-deploy-preflight.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 parseArgs(argv) {
+    const parsed = {
+        hotfix: false,
+        messageParts: [],
+    };
+    for (const current of argv) {
+        if (current === '--hotfix') {
+            parsed.hotfix = true;
+            continue;
+        }
+        parsed.messageParts.push(current);
+    }
+    return {
+        hotfix: parsed.hotfix,
+        message: parsed.messageParts.join(' ').trim(),
+    };
+}
+const options = parseArgs(process.argv.slice(2));
+const message = options.message;
+const root = workspaceRoot();
+const gitRoot = repoRoot(root);
+const branch = currentBranch(gitRoot);
+const scope = branch === STAGING_BRANCH ? 'staging' : branch === PRODUCTION_BRANCH ? 'prod' : 'local';
+applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope, override: true });
+if (!message) {
+    writeSaveReport({ ok: false, kind: 'usage', message: 'Treeseed save requires a commit message.' });
+    console.error('Treeseed save requires a commit message. Usage: treeseed save <message>');
+    process.exit(1);
+}
+if (!branch) {
+    writeSaveReport({ ok: false, kind: 'missing_branch', message: 'Treeseed save requires an active git branch.' });
+    console.error('Treeseed save requires an active git branch.');
+    process.exit(1);
+}
+if (branch === PRODUCTION_BRANCH && !options.hotfix) {
+    writeSaveReport({
+        ok: false,
+        kind: 'protected_branch',
+        branch,
+        message: 'Treeseed save is blocked on main. Use `treeseed release` for normal production promotion or `treeseed save --hotfix` for an explicit hotfix.',
+    });
+    console.error('Treeseed save is blocked on main. Use `treeseed release` for normal production promotion or `treeseed save --hotfix` for an explicit hotfix.');
+    process.exit(1);
+}
+try {
+    originRemoteUrl(gitRoot);
+}
+catch {
+    writeSaveReport({ ok: false, kind: 'missing_origin', message: 'Treeseed save requires an origin remote.' });
+    console.error('Treeseed save requires an origin remote.');
+    process.exit(1);
+}
+try {
+    runWorkspaceSavePreflight({ cwd: root });
+}
+catch (error) {
+    const kind = error?.kind ?? 'preflight_failed';
+    writeSaveReport({
+        ok: false,
+        kind,
+        message: error instanceof Error ? error.message : String(error),
+    });
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(error?.exitCode ?? 1);
+}
+if (!hasMeaningfulChanges(gitRoot)) {
+    writeSaveReport({ ok: false, kind: 'no_changes', message: 'Treeseed save found no meaningful repository changes to commit.' });
+    console.error('Treeseed save found no meaningful repository changes to commit.');
+    process.exit(1);
+}
+run('git', ['add', '-A'], { cwd: gitRoot });
+run('git', ['commit', '-m', message], { cwd: gitRoot });
+try {
+    if (remoteBranchExists(gitRoot, branch)) {
+        run('git', ['pull', '--rebase', 'origin', branch], { cwd: gitRoot });
+        run('git', ['push', 'origin', branch], { cwd: gitRoot });
+    }
+    else {
+        run('git', ['push', '-u', 'origin', branch], { cwd: gitRoot });
+    }
+}
+catch (error) {
+    const report = collectMergeConflictReport(gitRoot);
+    writeSaveReport({
+        ok: false,
+        kind: 'merge_conflict',
+        branch,
+        report,
+        formatted: formatMergeConflictReport(report, gitRoot, branch),
+    });
+    console.error(formatMergeConflictReport(report, gitRoot, branch));
+    process.exit(12);
+}
+const summary = {
+    ok: true,
+    kind: 'success',
+    message,
+    branch,
+    scope,
+    hotfix: options.hotfix,
+    root,
+    repositoryRoot: gitRoot,
+};
+writeSaveReport(summary);
+console.log('Treeseed save completed successfully.');
+console.log(`Branch: ${branch}`);
+console.log(`Environment scope: ${scope}`);

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

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

package/dist/scripts/workspace-start.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
+import { createBranchPreviewDeployTarget, deployTargetLabel, ensureGeneratedWranglerConfig, finalizeDeploymentState, printDeploySummary, provisionCloudflareResources, runRemoteD1Migrations, syncCloudflareSecrets, validateDeployPrerequisites, } from '../operations/services/deploy.js';
+import { createFeatureBranchFromStaging, pushBranch } from '../operations/services/git-workflow.js';
+import { packageScriptPath, resolveWranglerBin } from '../operations/services/runtime-tools.js';
+function parseArgs(argv) {
+    const parsed = {
+        branchName: null,
+        preview: false,
+    };
+    for (const current of argv) {
+        if (current === '--preview') {
+            parsed.preview = true;
+            continue;
+        }
+        if (!parsed.branchName) {
+            parsed.branchName = current;
+            continue;
+        }
+        throw new Error(`Unknown start argument: ${current}`);
+    }
+    if (!parsed.branchName) {
+        throw new Error('Usage: treeseed start <branch-name> [--preview]');
+    }
+    return parsed;
+}
+function runNodeScript(scriptPath, scriptArgs = [], cwd) {
+    const result = spawnSync(process.execPath, [scriptPath, ...scriptArgs], {
+        stdio: 'inherit',
+        cwd,
+        env: { ...process.env },
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+function runWranglerDeploy(configPath, cwd) {
+    const result = spawnSync(process.execPath, [resolveWranglerBin(), 'deploy', '--config', configPath], {
+        stdio: 'inherit',
+        cwd,
+        env: { ...process.env },
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+const options = parseArgs(process.argv.slice(2));
+const tenantRoot = process.cwd();
+const result = createFeatureBranchFromStaging(tenantRoot, options.branchName);
+pushBranch(result.repoDir, options.branchName, { setUpstream: true });
+if (!options.preview) {
+    console.log(`Created feature branch ${options.branchName} from staging.`);
+    console.log('Preview mode is disabled. Use local development for this branch.');
+    process.exit(0);
+}
+applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'staging', override: true });
+assertTreeseedCommandEnvironment({ tenantRoot, scope: 'staging', purpose: 'deploy' });
+validateDeployPrerequisites(tenantRoot, { requireRemote: true });
+const target = createBranchPreviewDeployTarget(options.branchName);
+const summary = provisionCloudflareResources(tenantRoot, { target });
+printDeploySummary(summary);
+const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot, { target });
+syncCloudflareSecrets(tenantRoot, { target });
+runRemoteD1Migrations(tenantRoot, { target });
+runNodeScript(packageScriptPath('tenant-build'), [], tenantRoot);
+runWranglerDeploy(wranglerPath, tenantRoot);
+const state = finalizeDeploymentState(tenantRoot, { target });
+console.log(`Treeseed start preview completed for ${options.branchName}.`);
+console.log(`Target: ${deployTargetLabel(target)}`);
+console.log(`Preview URL: ${state.lastDeployedUrl}`);

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,11 @@
+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') {
+        run('npm', ['run', 'test:unit'], { cwd: pkg.dir });
+        continue;
+    }
+    if (typeof pkg.packageJson.scripts?.test === 'string') {
+        run('npm', ['run', 'test'], { cwd: pkg.dir });
+    }
+}

package/dist/sdk-fields.d.ts

@@ -0,0 +1,11 @@
+import type { SdkModelDefinition, SdkModelFieldBinding, SdkSortSpec, SdkFilterCondition } from './sdk-types.ts';
+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-fields.js

@@ -0,0 +1,169 @@
+import {
+  resolveAliasedField
+} from "./field-aliases.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeFieldName(value) {
+  return value.trim().toLowerCase();
+}
+function readPathValue(source, path) {
+  const normalizedPath = path.replace(/^\$\.?/u, "");
+  if (!normalizedPath) {
+    return void 0;
+  }
+  return normalizedPath.split(".").reduce((current, segment) => {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    return current[segment];
+  }, source);
+}
+function readCandidateValue(record, candidate) {
+  if (candidate in record) {
+    return record[candidate];
+  }
+  if (isRecord(record.frontmatter) && candidate in record.frontmatter) {
+    return record.frontmatter[candidate];
+  }
+  return readPathValue(record, candidate);
+}
+function normalizeFieldBinding(binding, canonicalKey) {
+  const aliases = [...new Set((binding.aliases ?? []).map(normalizeFieldName).filter(Boolean))];
+  const contentKeys = [...new Set((binding.contentKeys ?? []).filter(Boolean))];
+  const dbColumns = [...new Set((binding.dbColumns ?? []).filter(Boolean))];
+  const payloadPaths = [...new Set((binding.payloadPaths ?? []).filter(Boolean))];
+  return {
+    ...binding,
+    key: canonicalKey,
+    aliases,
+    contentKeys,
+    dbColumns,
+    payloadPaths
+  };
+}
+function validateModelFieldAliases(definition) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [canonicalKey, rawBinding] of Object.entries(definition.fields ?? {})) {
+    if (!canonicalKey.trim()) {
+      throw new Error(`Model "${definition.name}" includes an empty canonical field key.`);
+    }
+    const binding = normalizeFieldBinding(rawBinding, canonicalKey);
+    for (const candidate of [canonicalKey, ...binding.aliases ?? []]) {
+      const normalized = normalizeFieldName(candidate);
+      const owner = seen.get(normalized);
+      if (owner && owner !== canonicalKey) {
+        throw new Error(
+          `Model "${definition.name}" reuses field alias "${candidate}" for both "${owner}" and "${canonicalKey}".`
+        );
+      }
+      seen.set(normalized, canonicalKey);
+    }
+  }
+  if (!(definition.pickField in (definition.fields ?? {}))) {
+    throw new Error(`Model "${definition.name}" pickField "${definition.pickField}" does not reference a defined field.`);
+  }
+  for (const fieldName of definition.filterableFields ?? []) {
+    if (!(fieldName in (definition.fields ?? {}))) {
+      throw new Error(`Model "${definition.name}" filterable field "${fieldName}" is not defined in fields.`);
+    }
+  }
+  for (const fieldName of definition.sortableFields ?? []) {
+    if (!(fieldName in (definition.fields ?? {}))) {
+      throw new Error(`Model "${definition.name}" sortable field "${fieldName}" is not defined in fields.`);
+    }
+  }
+}
+function resolveModelField(definition, requestedField) {
+  const registry = Object.fromEntries(
+    Object.entries(definition.fields ?? {}).map(([canonicalKey, rawBinding]) => [
+      canonicalKey,
+      normalizeFieldBinding(rawBinding, canonicalKey)
+    ])
+  );
+  return resolveAliasedField(registry, requestedField);
+}
+function readCanonicalFieldValue(definition, record, canonicalField) {
+  const binding = resolveModelField(definition, canonicalField);
+  for (const candidate of [
+    binding.key,
+    ...binding.contentKeys ?? [],
+    ...binding.dbColumns ?? [],
+    ...binding.payloadPaths ?? [],
+    ...binding.aliases ?? []
+  ]) {
+    const value = readCandidateValue(record, candidate);
+    if (value !== void 0) {
+      return binding.normalize ? binding.normalize(value) : value;
+    }
+  }
+  return void 0;
+}
+function normalizeRecordToCanonicalShape(definition, record) {
+  const normalized = { ...record };
+  for (const canonicalField of Object.keys(definition.fields ?? {})) {
+    const value = readCanonicalFieldValue(definition, record, canonicalField);
+    if (value !== void 0) {
+      normalized[canonicalField] = value;
+    }
+  }
+  return normalized;
+}
+function normalizeMutationData(definition, data) {
+  const next = { ...data };
+  for (const key of Object.keys(data)) {
+    const binding = resolveModelField(definition, key);
+    next[binding.key] = binding.normalize ? binding.normalize(data[key]) : data[key];
+    if (binding.key !== key) {
+      delete next[key];
+    }
+  }
+  return next;
+}
+function canonicalizeFrontmatter(definition, frontmatter, updates = {}) {
+  const normalizedExisting = normalizeRecordToCanonicalShape(definition, frontmatter);
+  const normalizedUpdates = normalizeMutationData(definition, updates);
+  const next = { ...frontmatter };
+  for (const [canonicalField, value] of Object.entries({ ...normalizedExisting, ...normalizedUpdates })) {
+    const binding = definition.fields[canonicalField];
+    if (!binding) {
+      continue;
+    }
+    const writeKey = binding.writeContentKey ?? binding.contentKeys?.[0] ?? canonicalField;
+    for (const key of [binding.key, ...binding.contentKeys ?? [], ...binding.aliases ?? []]) {
+      if (key !== writeKey) {
+        delete next[key];
+      }
+    }
+    next[writeKey] = value;
+  }
+  return next;
+}
+function normalizeFilterFields(definition, filters = []) {
+  return filters.map((filter) => {
+    const binding = resolveModelField(definition, filter.field);
+    return {
+      ...filter,
+      field: binding.key
+    };
+  });
+}
+function normalizeSortFields(definition, sort = []) {
+  return sort.map((entry) => {
+    const binding = resolveModelField(definition, entry.field);
+    return {
+      ...entry,
+      field: binding.key
+    };
+  });
+}
+export {
+  canonicalizeFrontmatter,
+  normalizeFilterFields,
+  normalizeMutationData,
+  normalizeRecordToCanonicalShape,
+  normalizeSortFields,
+  readCanonicalFieldValue,
+  resolveModelField,
+  validateModelFieldAliases
+};

package/dist/sdk-filters.d.ts

@@ -0,0 +1,4 @@
+import type { SdkContentEntry, SdkFilterCondition, SdkModelDefinition, SdkSortSpec } from './sdk-types.ts';
+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,3 +1,4 @@
+import { readCanonicalFieldValue } from "./sdk-fields.js";
 function toArray(value) {
   if (Array.isArray(value)) {
     return value;
@@ -11,19 +12,13 @@ function compareScalar(left, right) {
   if (typeof left === "number" && typeof right === "number") {
     return left - right;
   }
-  return String(left ?? "").localeCompare(String(right ?? ""));
-}
-function getFieldValue(entry, field) {
-  if (field in entry) {
-    return entry[field];
+  if (left instanceof Date || right instanceof Date) {
+    return new Date(String(left ?? 0)).valueOf() - new Date(String(right ?? 0)).valueOf();
   }
-  if ("frontmatter" in entry && entry.frontmatter && typeof entry.frontmatter === "object") {
-    return entry.frontmatter[field];
-  }
-  return void 0;
+  return String(left ?? "").localeCompare(String(right ?? ""));
 }
-function matchesFilter(entry, filter) {
-  const fieldValue = getFieldValue(entry, filter.field);
+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;
@@ -52,17 +47,19 @@ function matchesFilter(entry, filter) {
       return false;
   }
 }
-function applyFilters(items, filters = []) {
-  return items.filter((item) => filters.every((filter) => matchesFilter(item, filter)));
+function applyFilters(items, filters = [], definition) {
+  return items.filter((item) => filters.every((filter) => matchesFilter(item, filter, definition)));
 }
-function applySort(items, sort = []) {
+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 comparison = compareScalar(getFieldValue(left, spec.field), getFieldValue(right, spec.field));
+      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;
       }