@dinoxx/dinox-cli 1.1.1 → 2.1.0

package/dist/daemon/index.js

@@ -12,6 +12,7 @@ import { loadConfig } from '../config/store.js';
 import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { withAsyncRelease } from '../utils/asyncRelease.js';
+import { remainingDeadlineMs } from '../utils/deadline.js';
 import { getPackageVersion } from '../utils/version.js';
 const DAEMON_STOP_POLL_INTERVAL_MS = 100;
 const DAEMON_STOP_TIMEOUT_MS = 5_000;
@@ -63,9 +64,11 @@ async function waitForDaemonExit(instanceId, timeoutMs) {
     const info = await getDaemonInfo();
     return !info || info.instanceId !== instanceId;
 }
-async function expectedDaemonIdentity(baseConfig) {
+async function expectedDaemonIdentity(baseConfig, timeoutMs) {
     const resolved = baseConfig ?? resolveConfig(await loadConfig());
-    const { config } = await hydrateResolvedAuthIdentity(resolved, { timeoutMs: resolved.sync.timeoutMs });
+    const { config } = await hydrateResolvedAuthIdentity(resolved, {
+        timeoutMs: timeoutMs ?? resolved.sync.timeoutMs,
+    });
     return {
         version: getPackageVersion(),
         userId: config.auth.userId ?? null,
@@ -82,9 +85,29 @@ function matchesRuntimeTokenBinding(info, version, config) {
         && (!config.auth.userId || info.userId === config.auth.userId));
 }
 export async function startDaemonLocked(port, detached, options = {}) {
+    const maximumTimeoutMs = options.timeoutMs === undefined
+        ? undefined
+        : Math.max(0, Math.floor(options.timeoutMs));
+    const deadlineAtMs = maximumTimeoutMs === undefined
+        ? undefined
+        : Date.now() + maximumTimeoutMs;
+    const remainingStartTimeoutMs = (phase) => {
+        if (deadlineAtMs === undefined || maximumTimeoutMs === undefined) {
+            return undefined;
+        }
+        const remainingMs = remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+        if (remainingMs <= 0) {
+            throw new DinoxError('Failed to start daemon before the caller deadline expired.', {
+                code: 'DAEMON_START_TIMEOUT',
+                details: { phase },
+                recoverable: true,
+            });
+        }
+        return remainingMs;
+    };
     const baseConfig = resolveConfig(await loadConfig());
     const version = getPackageVersion();
-    const runningInfo = await getDaemonInfo();
+    const runningInfo = await getDaemonInfo(remainingStartTimeoutMs('initial-ping'));
     if (runningInfo) {
         if (matchesRuntimeTokenBinding(runningInfo, version, baseConfig)) {
             return { running: true, port, socketPath: getDaemonSocketPath(), transport: 'socket', detached, alreadyRunning: true };
@@ -94,7 +117,7 @@ export async function startDaemonLocked(port, detached, options = {}) {
             recoverable: true,
         });
     }
-    const expected = await expectedDaemonIdentity(baseConfig);
+    const expected = await expectedDaemonIdentity(baseConfig, remainingStartTimeoutMs('auth-hydration'));
     if (detached) {
         const args = ['daemon', 'start', '--port', String(port), '--no-detach'];
         const entrypoint = process.argv[1];
@@ -107,7 +130,7 @@ export async function startDaemonLocked(port, detached, options = {}) {
             env: { ...process.env, [DAEMON_CHILD_ENV]: '1' },
         });
         child.unref();
-        const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint);
+        const ready = await waitForFreshDaemon(expected.version, expected.userId, expected.tokenFingerprint, expected.runtimeConfigFingerprint, remainingStartTimeoutMs('ready-poll'));
         if (!ready) {
             child.kill('SIGTERM');
             throw new DinoxError('Failed to start daemon');

package/dist/daemon/lifecycle.d.ts

@@ -28,17 +28,22 @@ type DaemonLifecycleDependencies = {
     getPackageVersion: typeof getPackageVersion;
     printWarning: typeof printHumanReadableWarning;
 };
-export declare function captureDaemonSnapshot(overrides?: Partial<DaemonLifecycleDependencies>): Promise<DaemonSnapshot>;
+export declare function captureDaemonSnapshot(overrides?: Partial<DaemonLifecycleDependencies>, timeoutMs?: number): Promise<DaemonSnapshot>;
 export declare function daemonSnapshotIsFresh(config: ResolvedDinoxConfig, snapshot: DaemonSnapshot, version?: string): boolean;
 /** Caller must hold the daemon start lock until restore completes. */
 export declare function suspendDaemonForExclusiveAccessLocked(config: ResolvedDinoxConfig, timeoutMs: number, options?: {
     snapshot?: DaemonSnapshot;
     forceStop?: boolean;
+    deadlineAtMs?: number;
     dependencies?: Partial<DaemonLifecycleDependencies>;
 }): Promise<SuspendedDaemon>;
 /** Caller must hold the daemon start lock. */
-export declare function restoreSuspendedDaemonLocked(suspended: SuspendedDaemon, overrides?: Partial<DaemonLifecycleDependencies>): Promise<boolean>;
+export declare function restoreSuspendedDaemonLocked(suspended: SuspendedDaemon, overrides?: Partial<DaemonLifecycleDependencies>, options?: {
+    timeoutMs?: number;
+}): Promise<boolean>;
 export declare function withDaemonExclusiveAccess<T>(config: ResolvedDinoxConfig, timeoutMs: number, run: (control: DaemonExclusiveAccessControl) => Promise<T>, overrides?: Partial<DaemonLifecycleDependencies>, options?: {
     deadlineAtMs?: number;
+    operationDeadlineAtMs?: number;
+    cleanupFailureMode?: 'warn' | 'throw';
 }): Promise<T>;
 export {};

package/dist/daemon/lifecycle.js

@@ -1,6 +1,8 @@
 import { existsSync } from 'node:fs';
 import { getPowerSyncDbPath } from '../config/paths.js';
 import { fingerprintDaemonRuntimeConfig } from '../config/resolve.js';
+import { remainingDeadlineMs, runWithinDeadline } from '../utils/deadline.js';
+import { DinoxError } from '../utils/errors.js';
 import { printHumanReadableWarning } from '../utils/output.js';
 import { getPackageVersion } from '../utils/version.js';
 import { getDaemonInfo, isDaemonFresh, shutdownDaemonForExclusiveAccess, } from './client.js';
@@ -22,6 +24,21 @@ function dependencies(overrides) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function createLifecycleDeadlineError(phase, action) {
+    return new DinoxError(`Sync deadline exceeded while ${action}.`, {
+        code: 'SYNC_TIMEOUT',
+        details: { phase },
+        suggestion: 'Run `dino doctor --format json` to verify the local runtime before retrying sync.',
+        recoverable: true,
+    });
+}
+function requireRemainingDeadlineMs(deadlineAtMs, maximumTimeoutMs, phase, action) {
+    const remainingMs = remainingDeadlineMs(deadlineAtMs, maximumTimeoutMs);
+    if (deadlineAtMs !== undefined && remainingMs <= 0) {
+        throw createLifecycleDeadlineError(phase, action);
+    }
+    return Math.max(1, remainingMs);
+}
 function snapshotPort(snapshot) {
     const pidFileMatches = Boolean(snapshot.info
         && snapshot.pidInfo
@@ -29,10 +46,10 @@ function snapshotPort(snapshot) {
         && snapshot.pidInfo.instanceId === snapshot.info.instanceId);
     return pidFileMatches ? snapshot.pidInfo?.port ?? DEFAULT_DAEMON_PORT : DEFAULT_DAEMON_PORT;
 }
-export async function captureDaemonSnapshot(overrides = {}) {
+export async function captureDaemonSnapshot(overrides = {}, timeoutMs) {
     const deps = dependencies(overrides);
     return {
-        info: await deps.getDaemonInfo(),
+        info: await deps.getDaemonInfo(timeoutMs),
         pidInfo: deps.readPid(),
         socketExists: process.platform !== 'win32' && existsSync(getDaemonSocketPath()),
     };
@@ -44,12 +61,13 @@ export function daemonSnapshotIsFresh(config, snapshot, version = getPackageVers
 /** Caller must hold the daemon start lock until restore completes. */
 export async function suspendDaemonForExclusiveAccessLocked(config, timeoutMs, options = {}) {
     const deps = dependencies(options.dependencies ?? {});
-    const snapshot = options.snapshot ?? await captureDaemonSnapshot(deps);
+    const remainingTimeoutMs = (phase, action) => requireRemainingDeadlineMs(options.deadlineAtMs, timeoutMs, phase, action);
+    const snapshot = options.snapshot ?? await captureDaemonSnapshot(deps, remainingTimeoutMs('daemon-snapshot', 'inspecting the background daemon'));
     const wasFresh = daemonSnapshotIsFresh(config, snapshot, deps.getPackageVersion());
     const daemonUsesTargetDatabase = !snapshot.info
         || getPowerSyncDbPath(snapshot.info.userId) === getPowerSyncDbPath(config.auth.userId);
     const wasStopped = options.forceStop || daemonUsesTargetDatabase
-        ? await deps.shutdownDaemon(Math.min(timeoutMs, 10_000), snapshot.info?.instanceId)
+        ? await deps.shutdownDaemon(Math.min(remainingTimeoutMs('daemon-shutdown', 'stopping the background daemon'), 10_000), snapshot.info?.instanceId)
         : false;
     return {
         snapshot,
@@ -59,22 +77,26 @@ export async function suspendDaemonForExclusiveAccessLocked(config, timeoutMs, o
     };
 }
 /** Caller must hold the daemon start lock. */
-export async function restoreSuspendedDaemonLocked(suspended, overrides = {}) {
+export async function restoreSuspendedDaemonLocked(suspended, overrides = {}, options = {}) {
     if (!suspended.wasStopped || !suspended.wasFresh) {
         return false;
     }
     const deps = dependencies(overrides);
-    await deps.startDaemonLocked(suspended.port, true, { quiet: true });
+    await deps.startDaemonLocked(suspended.port, true, {
+        quiet: true,
+        timeoutMs: options.timeoutMs,
+    });
     return true;
 }
 export async function withDaemonExclusiveAccess(config, timeoutMs, run, overrides = {}, options = {}) {
     const deps = dependencies(overrides);
-    const remainingTimeoutMs = () => options.deadlineAtMs === undefined
-        ? timeoutMs
-        : Math.max(1, Math.min(timeoutMs, options.deadlineAtMs - Date.now()));
-    const releaseStartLock = await deps.acquireStartLock(remainingTimeoutMs());
+    const operationDeadlineAtMs = options.operationDeadlineAtMs ?? options.deadlineAtMs;
+    const remainingOperationTimeoutMs = (phase, action) => requireRemainingDeadlineMs(operationDeadlineAtMs, timeoutMs, phase, action);
+    const remainingCleanupTimeoutMs = () => Math.max(1, remainingDeadlineMs(options.deadlineAtMs, timeoutMs));
+    const releaseStartLock = await deps.acquireStartLock(remainingOperationTimeoutMs('daemon-lock-acquire', 'acquiring the daemon lifecycle lock'));
     let suspended = null;
     let restoreAllowed = true;
+    let cleanupError;
     let outcome;
     const control = {
         suppressRestore() {
@@ -82,7 +104,8 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
         },
     };
     try {
-        suspended = await suspendDaemonForExclusiveAccessLocked(config, remainingTimeoutMs(), {
+        suspended = await suspendDaemonForExclusiveAccessLocked(config, remainingOperationTimeoutMs('daemon-suspend', 'suspending the background daemon'), {
+            deadlineAtMs: operationDeadlineAtMs,
             dependencies: deps,
         });
         try {
@@ -97,22 +120,39 @@ export async function withDaemonExclusiveAccess(config, timeoutMs, run, override
     }
     finally {
         if (suspended && restoreAllowed) {
+            const suspendedDaemon = suspended;
             try {
-                await restoreSuspendedDaemonLocked(suspended, deps);
+                await runWithinDeadline(() => restoreSuspendedDaemonLocked(suspendedDaemon, deps, {
+                    timeoutMs: remainingCleanupTimeoutMs(),
+                }), {
+                    deadlineAtMs: options.deadlineAtMs,
+                    maximumTimeoutMs: timeoutMs,
+                    createTimeoutError: () => createLifecycleDeadlineError('daemon-restore', 'restoring the background daemon'),
+                });
             }
             catch (error) {
+                cleanupError = error;
                 deps.printWarning(`warning: failed to restore daemon after local command: ${errorMessage(error)}`);
             }
         }
         try {
-            await releaseStartLock();
+            await runWithinDeadline(releaseStartLock, {
+                deadlineAtMs: options.deadlineAtMs,
+                maximumTimeoutMs: timeoutMs,
+                createTimeoutError: () => createLifecycleDeadlineError('daemon-lock-release', 'releasing the daemon lifecycle lock'),
+                runWhenExpired: true,
+            });
         }
         catch (error) {
+            cleanupError ??= error;
             deps.printWarning(`warning: failed to release daemon lifecycle lock: ${errorMessage(error)}`);
         }
     }
     if (!outcome.ok) {
         throw outcome.error;
     }
+    if (cleanupError && options.cleanupFailureMode === 'throw') {
+        throw cleanupError;
+    }
     return outcome.value;
 }

package/dist/daemon/pid.d.ts

@@ -19,5 +19,5 @@ export declare function removePid(expectedInstanceId?: string, options?: {
     expectedPid?: number;
 }): boolean;
 export declare function isProcessRunning(pid: number): boolean;
-export declare function isLegacyDaemonProcess(pid: number, daemonUptimeMs: number): Promise<boolean>;
+export declare function isLegacyDaemonProcess(pid: number, daemonUptimeMs: number, timeoutMs?: number): Promise<boolean>;
 export declare function acquireDaemonStartLock(timeoutMs?: number): Promise<() => Promise<void>>;

package/dist/daemon/pid.js

@@ -139,10 +139,13 @@ function commandLooksLikeLegacyDaemon(command) {
     return /(?:^|[\\/\s])dino(?:x)?(?:\.[cm]?[jt]s)?["']?\s+daemon\s+start(?:\s|$)/i.test(command)
         && /(?:^|\s)--no-detach(?:\s|$)/.test(command);
 }
-export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
+export async function isLegacyDaemonProcess(pid, daemonUptimeMs, timeoutMs = 2_000) {
     if (!Number.isInteger(pid) || pid <= 0 || !Number.isFinite(daemonUptimeMs) || daemonUptimeMs < 0) {
         return false;
     }
+    const commandTimeoutMs = Number.isFinite(timeoutMs)
+        ? Math.max(1, Math.min(2_000, Math.floor(timeoutMs)))
+        : 2_000;
     try {
         if (process.platform === 'win32') {
             const command = [
@@ -152,7 +155,7 @@ export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
                 '  [Console]::Write($p.CommandLine);',
                 '}',
             ].join(' ');
-            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command], { encoding: 'utf8', timeout: 2_000, maxBuffer: 64 * 1024 });
+            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command], { encoding: 'utf8', timeout: commandTimeoutMs, maxBuffer: 64 * 1024 });
             const newline = stdout.indexOf('\n');
             if (newline < 0) {
                 return false;
@@ -163,7 +166,7 @@ export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
                 && Math.abs(processUptimeMs - daemonUptimeMs) <= LEGACY_DAEMON_UPTIME_TOLERANCE_MS
                 && commandLooksLikeLegacyDaemon(stdout.slice(newline + 1).trim());
         }
-        const { stdout } = await execFileAsync('ps', ['-ww', '-p', String(pid), '-o', 'etime=', '-o', 'command='], { encoding: 'utf8', timeout: 2_000, maxBuffer: 64 * 1024 });
+        const { stdout } = await execFileAsync('ps', ['-ww', '-p', String(pid), '-o', 'etime=', '-o', 'command='], { encoding: 'utf8', timeout: commandTimeoutMs, maxBuffer: 64 * 1024 });
         const match = stdout.trim().match(/^(\S+)\s+([\s\S]+)$/);
         if (!match) {
             return false;

package/dist/dinox.js

@@ -2,6 +2,7 @@
 import { createCli } from './cli.js';
 import { buildStructuredErrorPayload, isDinoxError } from './utils/errors.js';
 import { clearRequestedStructuredOutputFormat, parseStructuredOutputFormatFromArgv, printError, printHumanReadableError, setRequestedStructuredOutputFormat, } from './utils/output.js';
+import { exitProcessAfterFlushing } from './utils/processExit.js';
 function normalizeArgv(argv) {
     // pnpm/npm script forwarding can prepend a standalone "--".
     if (argv[0] === '--') {
@@ -25,7 +26,12 @@ function isCommanderError(error) {
         && error.code.startsWith('commander.')
         && typeof error.exitCode === 'number';
 }
-main().catch((error) => {
+async function exitAfterFatalCleanup(error, exitCode) {
+    if (isDinoxError(error) && error.requiresProcessExit) {
+        await exitProcessAfterFlushing(exitCode);
+    }
+}
+main().catch(async (error) => {
     if (isCommanderError(error)) {
         process.exitCode = error.exitCode === 0 ? 0 : 2;
         return;
@@ -46,6 +52,7 @@ main().catch((error) => {
         setRequestedStructuredOutputFormat(format);
         printError(payload, format);
         clearRequestedStructuredOutputFormat();
+        await exitAfterFatalCleanup(error, exitCode);
         return;
     }
     printHumanReadableError(payload.message);
@@ -59,4 +66,5 @@ main().catch((error) => {
     if (verbose && payload.stack) {
         printHumanReadableError(payload.stack);
     }
+    await exitAfterFatalCleanup(error, exitCode);
 });

package/dist/powersync/exclusiveRuntime.d.ts

@@ -13,6 +13,7 @@ export declare function withExclusivePowerSync<T>(args: {
     offline: boolean;
     timeoutMs: number;
     deadlineAtMs?: number;
+    operationDeadlineAtMs?: number;
     waitForInitialSync?: boolean;
     expectedTokenFingerprint?: string | null;
     cleanupFailureMode?: 'warn' | 'throw';

package/dist/powersync/exclusiveRuntime.js

@@ -1,4 +1,6 @@
 import { withDaemonExclusiveAccess } from '../daemon/lifecycle.js';
+import { runWithinDeadline, remainingDeadlineMs } from '../utils/deadline.js';
+import { DinoxError } from '../utils/errors.js';
 import { printHumanReadableWarning } from '../utils/output.js';
 import { closePowerSyncAndReleaseOwner, connectPowerSync, } from './runtime.js';
 const exclusivePowerSyncDependencies = {
@@ -10,16 +12,24 @@ const exclusivePowerSyncDependencies = {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function createRuntimeCleanupDeadlineError() {
+    return new DinoxError('Sync deadline exceeded while closing the local PowerSync runtime.', {
+        code: 'SYNC_TIMEOUT',
+        details: { phase: 'powersync-cleanup' },
+        suggestion: 'Run `dino doctor --format json` to verify the local runtime before retrying sync.',
+        recoverable: true,
+        requiresProcessExit: true,
+    });
+}
 export async function withExclusivePowerSync(args, run, overrides = {}) {
     const dependencies = { ...exclusivePowerSyncDependencies, ...overrides };
-    const { cleanupFailureMode, deadlineAtMs, ...connectArgs } = args;
-    const remainingTimeoutMs = () => deadlineAtMs === undefined
-        ? args.timeoutMs
-        : Math.max(1, Math.min(args.timeoutMs, deadlineAtMs - Date.now()));
-    return dependencies.withDaemonExclusiveAccess(args.config, remainingTimeoutMs(), async (daemonLifecycle) => {
+    const { cleanupFailureMode, deadlineAtMs, operationDeadlineAtMs = deadlineAtMs, ...connectArgs } = args;
+    const remainingOperationTimeoutMs = () => Math.max(1, remainingDeadlineMs(operationDeadlineAtMs, args.timeoutMs));
+    const remainingTotalTimeoutMs = () => Math.max(1, remainingDeadlineMs(deadlineAtMs, args.timeoutMs));
+    return dependencies.withDaemonExclusiveAccess(args.config, remainingTotalTimeoutMs(), async (daemonLifecycle) => {
         const connected = await dependencies.connectPowerSync({
             ...connectArgs,
-            timeoutMs: remainingTimeoutMs(),
+            timeoutMs: remainingOperationTimeoutMs(),
         });
         let outcome;
         try {
@@ -30,7 +40,11 @@ export async function withExclusivePowerSync(args, run, overrides = {}) {
         }
         let cleanupError;
         try {
-            await dependencies.closePowerSyncAndReleaseOwner(connected.db, connected.releaseOwner);
+            await runWithinDeadline(() => dependencies.closePowerSyncAndReleaseOwner(connected.db, connected.releaseOwner), {
+                deadlineAtMs,
+                maximumTimeoutMs: args.timeoutMs,
+                createTimeoutError: createRuntimeCleanupDeadlineError,
+            });
         }
         catch (error) {
             cleanupError = error;
@@ -44,5 +58,9 @@ export async function withExclusivePowerSync(args, run, overrides = {}) {
             throw cleanupError;
         }
         return outcome.value;
-    }, {}, { deadlineAtMs });
+    }, {}, {
+        deadlineAtMs,
+        operationDeadlineAtMs,
+        cleanupFailureMode,
+    });
 }

package/dist/powersync/runtime.d.ts

@@ -1,6 +1,7 @@
 import { PowerSyncDatabase } from '@powersync/node';
-import type { AbstractPowerSyncDatabase, SyncStatusOptions } from '@powersync/common';
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import type { ResolvedDinoxConfig } from '../config/types.js';
+import type { SyncStatusRaw } from './syncGate.js';
 export type ConnectResult = {
     db: PowerSyncDatabase;
     dbPath: string;
@@ -29,7 +30,7 @@ export declare function getStatusSnapshot(db: AbstractPowerSyncDatabase): {
             message: string;
         };
     };
-    raw: SyncStatusOptions;
+    raw: SyncStatusRaw;
 };
 export declare function connectPowerSync(args: {
     config: ResolvedDinoxConfig;

package/dist/powersync/runtime.js

@@ -88,8 +88,25 @@ async function ensureDataDir() {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
     return dir;
 }
+function readSyncStatus(status) {
+    if (!status)
+        return {};
+    return {
+        connected: status.connected,
+        connecting: status.connecting,
+        hasSynced: status.hasSynced,
+        lastSyncedAt: status.lastSyncedAt,
+        dataFlow: {
+            downloading: status.downloading,
+            uploading: status.uploading,
+            downloadError: status.downloadError,
+            uploadError: status.uploadError,
+        },
+        priorityStatusEntries: status.priorityStatusEntries,
+    };
+}
 export function getStatusSnapshot(db) {
-    const raw = db.currentStatus?.toJSON?.() ?? {};
+    const raw = readSyncStatus(db.currentStatus);
     const lastSyncedAt = raw.lastSyncedAt instanceof Date ? raw.lastSyncedAt.toISOString() : raw.lastSyncedAt ?? null;
     const dataFlow = raw.dataFlow ?? {};
     return {
@@ -185,8 +202,7 @@ export async function connectPowerSync(args) {
             ? createPowerSyncUploadHandler({
                 authorization: args.config.auth.authorization,
                 uploadBaseUrl: args.config.powersync.uploadBaseUrl,
-                uploadV4Path: args.config.powersync.uploadV4Path,
-                uploadV2Path: args.config.powersync.uploadV2Path,
+                uploadPath: args.config.powersync.uploadPath,
                 timeoutMs: args.timeoutMs,
             })
             : undefined;

package/dist/powersync/schema/content.d.ts

@@ -1,78 +1 @@
-import { Table } from '@powersync/common';
-export declare const c_card_box: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    name: import("@powersync/common").BaseColumnType<string | null>;
-    type: import("@powersync/common").BaseColumnType<string | null>;
-    cover_url: import("@powersync/common").BaseColumnType<string | null>;
-    prompt: import("@powersync/common").BaseColumnType<string | null>;
-    headers: import("@powersync/common").BaseColumnType<string | null>;
-    priority: import("@powersync/common").BaseColumnType<number | null>;
-    created_at: import("@powersync/common").BaseColumnType<string | null>;
-    updated_at: import("@powersync/common").BaseColumnType<string | null>;
-    extra_data: import("@powersync/common").BaseColumnType<string | null>;
-    user_no: import("@powersync/common").BaseColumnType<string | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-    template_id: import("@powersync/common").BaseColumnType<string | null>;
-}>;
-export declare const c_card_note: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    box_id: import("@powersync/common").BaseColumnType<string | null>;
-    content: import("@powersync/common").BaseColumnType<string | null>;
-    created_at: import("@powersync/common").BaseColumnType<string | null>;
-    updated_at: import("@powersync/common").BaseColumnType<string | null>;
-    extra_data: import("@powersync/common").BaseColumnType<string | null>;
-    user_no: import("@powersync/common").BaseColumnType<string | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-    origin_note_id: import("@powersync/common").BaseColumnType<string | null>;
-    origin_type: import("@powersync/common").BaseColumnType<string | null>;
-    output_type: import("@powersync/common").BaseColumnType<string | null>;
-    is_array: import("@powersync/common").BaseColumnType<number | null>;
-}>;
-export declare const c_cmd: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    zone: import("@powersync/common").BaseColumnType<string | null>;
-    type: import("@powersync/common").BaseColumnType<string | null>;
-    cmd: import("@powersync/common").BaseColumnType<string | null>;
-    name: import("@powersync/common").BaseColumnType<string | null>;
-    priority: import("@powersync/common").BaseColumnType<number | null>;
-    is_show: import("@powersync/common").BaseColumnType<number | null>;
-    description: import("@powersync/common").BaseColumnType<string | null>;
-    extra_data: import("@powersync/common").BaseColumnType<string | null>;
-    user_id: import("@powersync/common").BaseColumnType<string | null>;
-    insert_at: import("@powersync/common").BaseColumnType<string | null>;
-    update_at: import("@powersync/common").BaseColumnType<string | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-    template_id: import("@powersync/common").BaseColumnType<string | null>;
-    meta_data: import("@powersync/common").BaseColumnType<string | null>;
-    output: import("@powersync/common").BaseColumnType<string | null>;
-    output_param: import("@powersync/common").BaseColumnType<string | null>;
-    category: import("@powersync/common").BaseColumnType<string | null>;
-}>;
-export declare const c_note_template: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    content: import("@powersync/common").BaseColumnType<string | null>;
-    name: import("@powersync/common").BaseColumnType<string | null>;
-    priority: import("@powersync/common").BaseColumnType<number | null>;
-    is_show: import("@powersync/common").BaseColumnType<number | null>;
-    extra_data: import("@powersync/common").BaseColumnType<string | null>;
-    user_id: import("@powersync/common").BaseColumnType<string | null>;
-    insert_at: import("@powersync/common").BaseColumnType<string | null>;
-    update_at: import("@powersync/common").BaseColumnType<string | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-}>;
-export declare const c_zettel_box: Table<{
-    id: import("@powersync/common").BaseColumnType<string | null>;
-    name: import("@powersync/common").BaseColumnType<string | null>;
-    path: import("@powersync/common").BaseColumnType<string | null>;
-    parent_id: import("@powersync/common").BaseColumnType<string | null>;
-    description: import("@powersync/common").BaseColumnType<string | null>;
-    color: import("@powersync/common").BaseColumnType<string | null>;
-    priority: import("@powersync/common").BaseColumnType<number | null>;
-    is_show: import("@powersync/common").BaseColumnType<number | null>;
-    cover_url: import("@powersync/common").BaseColumnType<string | null>;
-    created_at: import("@powersync/common").BaseColumnType<string | null>;
-    updated_at: import("@powersync/common").BaseColumnType<string | null>;
-    extra_data: import("@powersync/common").BaseColumnType<string | null>;
-    user_no: import("@powersync/common").BaseColumnType<string | null>;
-    is_del: import("@powersync/common").BaseColumnType<number | null>;
-}>;
+export { c_card_box, c_card_note, c_cmd, c_note_template, c_zettel_box, } from './electronCanonical.js';

package/dist/powersync/schema/content.js

@@ -1,78 +1 @@
-import { column, Table } from '@powersync/common';
-export const c_card_box = new Table({
-    id: column.text,
-    name: column.text,
-    type: column.text,
-    cover_url: column.text,
-    prompt: column.text,
-    headers: column.text,
-    priority: column.integer,
-    created_at: column.text,
-    updated_at: column.text,
-    extra_data: column.text,
-    user_no: column.text,
-    is_del: column.integer,
-    template_id: column.text,
-});
-export const c_card_note = new Table({
-    id: column.text,
-    box_id: column.text,
-    content: column.text,
-    created_at: column.text,
-    updated_at: column.text,
-    extra_data: column.text,
-    user_no: column.text,
-    is_del: column.integer,
-    origin_note_id: column.text,
-    origin_type: column.text,
-    output_type: column.text,
-    is_array: column.integer,
-});
-export const c_cmd = new Table({
-    id: column.text,
-    zone: column.text,
-    type: column.text,
-    cmd: column.text,
-    name: column.text,
-    priority: column.integer,
-    is_show: column.integer,
-    description: column.text,
-    extra_data: column.text,
-    user_id: column.text,
-    insert_at: column.text,
-    update_at: column.text,
-    is_del: column.integer,
-    template_id: column.text,
-    meta_data: column.text,
-    output: column.text,
-    output_param: column.text,
-    category: column.text,
-});
-export const c_note_template = new Table({
-    id: column.text,
-    content: column.text,
-    name: column.text,
-    priority: column.integer,
-    is_show: column.integer,
-    extra_data: column.text,
-    user_id: column.text,
-    insert_at: column.text,
-    update_at: column.text,
-    is_del: column.integer,
-});
-export const c_zettel_box = new Table({
-    id: column.text,
-    name: column.text,
-    path: column.text,
-    parent_id: column.text,
-    description: column.text,
-    color: column.text,
-    priority: column.integer,
-    is_show: column.integer,
-    cover_url: column.text,
-    created_at: column.text,
-    updated_at: column.text,
-    extra_data: column.text,
-    user_no: column.text,
-    is_del: column.integer,
-});
+export { c_card_box, c_card_note, c_cmd, c_note_template, c_zettel_box, } from './electronCanonical.js';