@crewx/sdk 0.9.0-rc.15 → 0.9.0-rc.151

package/dist/repository/thread.repository.d.ts

@@ -1,8 +1,81 @@
 import { BaseSqliteRepository } from './base-sqlite-repository.js';
+import { RepositoryError } from './errors.js';
 import { threads } from '../schema/index.js';
-import type { TaskRow } from './task.repository.js';
+import { type TaskStatus } from './task-status.js';
+import type { ThreadOriginRow } from './thread-origin-verdict.js';
+import type { TaskRow, TaskListRow } from './task.repository.js';
+export type { ThreadOriginRow } from './thread-origin-verdict.js';
 export type ThreadRow = typeof threads.$inferSelect;
 export type NewThread = typeof threads.$inferInsert;
+export type ThreadActorKind = NonNullable<NewThread['created_by_kind']>;
+export interface ThreadCreationOptions {
+    createdByKind?: ThreadActorKind | null;
+    createdById?: string | null;
+    createdByTaskId?: string | null;
+}
+export interface CreateAppLaunchThreadInput {
+    threadId: string;
+    workspaceId: string;
+    platform: string;
+    title: string;
+    appId: string;
+    createdById: string | null;
+    initialAgentId?: string;
+}
+export type CreateAppLaunchThreadResult = {
+    status: 'created';
+    thread: ThreadRow;
+} | {
+    status: 'existing';
+    thread: ThreadRow;
+} | {
+    status: 'conflict';
+};
+export interface TaskDescendantSummary {
+    total: number;
+    running: number;
+    pending: number;
+    paused: number;
+    success: number;
+    failed: number;
+    stopped: number;
+    runnerLost: number;
+    checkedAt: string;
+}
+export interface TaskDescendantRow {
+    task: TaskRow;
+    parentTaskId: string;
+    parentAgentId: string | null;
+    depth: number;
+}
+export interface TaskDescendantListOptions {
+    states?: readonly TaskStatus[];
+    limit?: number;
+    cursor?: string | null;
+    maxDepth?: number;
+}
+export interface TaskDescendantList {
+    rows: TaskDescendantRow[];
+    summary: TaskDescendantSummary;
+    nextCursor: string | null;
+    traversalTruncated: boolean;
+}
+export type ThreadOriginFilter = 'direct' | 'delegated' | 'all';
+type ThreadOriginScope = Exclude<ThreadOriginFilter, 'all'>;
+export interface ThreadTitleMetadataPatch {
+    priority?: string | null;
+    state?: string | null;
+}
+export interface ThreadTitleMetadataPatchResult {
+    threadId: string;
+    priority: string | null;
+    state: string | null;
+}
+export type ThreadTitleMetadataPatchErrorReason = 'THREAD_TITLE_PATCH_EMPTY' | 'THREAD_TITLE_PATCH_INVALID';
+export declare class ThreadTitleMetadataPatchError extends RepositoryError {
+    readonly reason: ThreadTitleMetadataPatchErrorReason;
+    constructor(reason: ThreadTitleMetadataPatchErrorReason, message?: string);
+}
 export declare class ThreadRepository extends BaseSqliteRepository {
     private readonly dbPath?;
     constructor(opts?: {
@@ -11,10 +84,22 @@ export declare class ThreadRepository extends BaseSqliteRepository {
     });
     resolveDbPath(): string;
     private openHandle;
-    private validateWorkspaceId;
     private topLevelTaskPredicateSql;
-    findAllThreads(workspaceId?: string): ThreadRow[];
+    private workflowAnchorPredicateSql;
+    private descendantTraversalSql;
+    private descendantSkippedSql;
+    private findAllThreadsQuery;
+    private findThreadIdsQuery;
+    private readThreadIds;
+    private findThreadSortKeysQuery;
+    private readThreadSortKeys;
+    private readThreadRowsByIds;
+    private readThreadRows;
+    findAllThreads(workspaceId?: string, createdByKind?: ThreadActorKind): ThreadRow[];
+    explainFindAllThreadsPlan(workspaceId?: string, createdByKind?: ThreadActorKind): string[];
+    findThreadsByIdsOrTitles(ids: string[], workspaceId?: string): ThreadRow[];
     findThreadById(threadId: string, workspaceId?: string): ThreadRow | undefined;
+    createAppLaunchThread(input: CreateAppLaunchThreadInput): CreateAppLaunchThreadResult;
     threadExists(threadId: string, workspaceId?: string): boolean;
     aggregateTaskStats(threadId: string, workspaceId?: string): {
         taskCount: number;
@@ -23,22 +108,44 @@ export declare class ThreadRepository extends BaseSqliteRepository {
         cachedInputTokens: number;
         costUsd: number;
         agentIds: string[];
+        delegated: {
+            taskCount: number;
+            inputTokens: number;
+            outputTokens: number;
+            cachedInputTokens: number;
+            costUsd: number;
+        };
     };
-    findTopLevelTasks(threadId: string, workspaceId?: string, limit?: number): TaskRow[];
+    getDescendantSummaryByTaskId(threadId: string, workspaceId?: string): Record<string, TaskDescendantSummary>;
+    listDescendantsByTaskId(taskId: string, workspaceId: string, options?: TaskDescendantListOptions): TaskDescendantList | undefined;
+    findTopLevelTasks(threadId: string, workspaceId?: string, limit?: number, ownAgentId?: string): TaskRow[];
     findAllTasks(threadId: string, workspaceId?: string): TaskRow[];
     findTaskById(threadId: string, taskId: string, workspaceId?: string): {
         task: TaskRow;
         children: TaskRow[];
     } | undefined;
-    batchFetchTasks(threadIds: string[], workspaceId?: string): Map<string, TaskRow[]>;
+    private batchFetchTasksQuery;
+    batchFetchTasks(threadIds: string[], workspaceId?: string): Map<string, TaskListRow[]>;
+    private findThreadOriginsQuery;
+    private findCreatorPointersQuery;
+    private findTaskOriginLineageQuery;
+    findThreadOrigins(threadIds: string[], workspaceId?: string): Map<string, ThreadOriginRow>;
+    findThreadsByOrigin(origin: ThreadOriginScope, workspaceId?: string): ThreadRow[];
+    findRecentDirectThreads(workspaceId: string, limit?: number): {
+        threads: ThreadRow[];
+        originsByThread: Map<string, ThreadOriginRow>;
+    };
+    explainBatchFetchTasksPlan(threadIds: string[], workspaceId?: string): string[];
+    explainFindThreadOriginsPlan(threadIds: string[], workspaceId?: string): string[];
+    explainFindThreadsByOriginPlan(origin: ThreadOriginScope, workspaceId?: string): string[];
     updateThreadTitle(threadId: string, title: string, workspaceId?: string): void;
     upsertThread(threadId: string, opts: {
         platform: string;
         workspaceId?: string;
         title?: string;
         titleLocked?: boolean;
-    }): void;
-    ensureThread(threadId: string, platform: string, workspaceId?: string): void;
+    } & ThreadCreationOptions): void;
+    ensureThread(threadId: string, platform: string, workspaceId?: string, creator?: ThreadCreationOptions): void;
     saveUserMessage(threadId: string, text: string, opts?: {
         platform?: string;
         model?: string;
@@ -56,6 +163,7 @@ export declare class ThreadRepository extends BaseSqliteRepository {
         title?: string;
         titleLocked?: boolean;
     }): void;
+    patchThreadTitleMetadata(threadId: string, patch: ThreadTitleMetadataPatch, workspaceId?: string): ThreadTitleMetadataPatchResult | ThreadTitleMetadataPatchError | null;
     togglePin(threadId: string, workspaceId?: string): {
         pinned: boolean;
     } | null;

package/dist/repository/usage-backfill.d.ts

@@ -0,0 +1,62 @@
+export type UsageBackfillMode = 'dry-run' | 'apply' | 'verify' | 'restore';
+export declare const USAGE_BACKFILL_TERMINAL_STATUSES: readonly ["success", "failed", "completed"];
+export declare const USAGE_BACKFILL_MAX_LATE_USAGE_AGE_MS: number;
+export declare const USAGE_BACKFILL_UNDO_SCHEMA_VERSION = 1;
+export declare const USAGE_BACKFILL_SNAPSHOT_ROW_BYTES = 2048;
+export declare const USAGE_BACKFILL_MIN_FREE_SPACE_RESERVE_BYTES: number;
+export type UsageAccountingReason = 'pre-instrumentation' | 'provider-no-usage' | 'suppressed-by-adapter' | 'not-captured';
+export interface UsageBackfillOptions {
+    mode: UsageBackfillMode;
+    dbPath?: string;
+    backupPath?: string;
+    restorePath?: string;
+    now?: Date | string | number;
+}
+export interface UsageBackfillProviderStats {
+    candidates: number;
+    recovered: number;
+    unavailable: number;
+    deferred: number;
+}
+export interface UsageBackfillFailure {
+    taskId: string;
+    reason: string;
+}
+export interface UsageBackfillReport {
+    mode: UsageBackfillMode;
+    ok: boolean;
+    dbPath: string;
+    scannedTasks: number;
+    terminalTasks: number;
+    rawTargetTasks: number;
+    candidateTasks: number;
+    recoveredTasks: number;
+    unavailableTasks: number;
+    deferredTasks: number;
+    changedTasks: number;
+    wouldChangeTasks: number;
+    accountingTasks: number;
+    remainingTargetTasks: number;
+    providerDistribution: Record<string, UsageBackfillProviderStats>;
+    reasonCounts: Record<UsageAccountingReason, number>;
+    estimatedFreeSpaceBytes: number;
+    requiredFreeSpaceBytes: number;
+    availableFreeSpaceBytes: number;
+    minimumFreeSpaceReserveBytes: number;
+    freeSpaceGatePassed: boolean;
+    backupPath?: string;
+    snapshotPath?: string;
+    backupMethod?: 'row-undo-snapshot';
+    restored: number;
+    skippedConflict: number;
+    conflictSamples: UsageBackfillConflict[];
+    blockedReason?: string;
+    failures: UsageBackfillFailure[];
+    warnings: string[];
+}
+export interface UsageBackfillConflict {
+    taskId: string;
+    fields: string[];
+}
+export declare function classifyUsageAccountingReason(provider: string | undefined): UsageAccountingReason;
+export declare function runUsageBackfill(options: UsageBackfillOptions): Promise<UsageBackfillReport>;

package/dist/repository/usage-from-logs.d.ts

@@ -0,0 +1,21 @@
+import type { CliProviderAdapter } from '../provider/cli/adapter.types.js';
+import type { TaskLogRepositoryContract } from './task-log.repository.js';
+export interface RecoveredTaskUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens: number;
+    costUsd: number;
+    model: string | null;
+}
+export interface TaskLogUsageRecovery {
+    stdout: string;
+    adapter: CliProviderAdapter;
+    usage?: RecoveredTaskUsage;
+}
+export interface RecoverUsageFromTaskLogsOptions {
+    taskLogRepository: Pick<TaskLogRepositoryContract, 'readLogs'>;
+    taskId: string;
+    provider?: string | null;
+    model?: string | null;
+}
+export declare function recoverUsageFromTaskLogs(options: RecoverUsageFromTaskLogsOptions): TaskLogUsageRecovery | undefined;

package/dist/repository/workspace.repository.d.ts

@@ -48,6 +48,9 @@ export declare class WorkspaceRepository extends BaseSqliteRepository {
         total: number;
     };
     findById(id: string): ProjectRow | undefined;
+    toggleStar(id: string): {
+        starred: boolean;
+    } | null;
     findAgentsByProject(id: string): string[];
     findThreadsByProject(id: string, params: {
         limit: number;

package/dist/schema/agent-suggestions.d.ts

@@ -0,0 +1,199 @@
+export declare const agent_suggestions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "agent_suggestions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        workspace_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "workspace_id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        agent_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "agent_id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        task_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "task_id";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "type";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        applied_commit_sha: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "applied_commit_sha";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updated_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "agent_suggestions";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type AgentSuggestion = typeof agent_suggestions.$inferSelect;
+export type NewAgentSuggestion = typeof agent_suggestions.$inferInsert;

package/dist/schema/common-codes.d.ts

@@ -0,0 +1,216 @@
+export declare const COMMON_CODE_GROUPS: readonly ["THREAD_STATE", "THREAD_PRIORITY"];
+export type CommonCodeGroup = (typeof COMMON_CODE_GROUPS)[number];
+export declare const COMMON_CODE_COLORS: readonly ["gray", "blue", "violet", "green", "amber", "orange", "red", "pink"];
+export type CommonCodeColor = (typeof COMMON_CODE_COLORS)[number];
+export declare const common_codes: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "common_codes";
+    schema: undefined;
+    columns: {
+        code_group: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "code_group";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        code: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "code";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        code_name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "code_name";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        color: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "color";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sort_order: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "sort_order";
+            tableName: "common_codes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspace_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "workspace_id";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        is_builtin: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "is_builtin";
+            tableName: "common_codes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        is_archived: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "is_archived";
+            tableName: "common_codes";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "metadata";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updated_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "common_codes";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type CommonCode = typeof common_codes.$inferSelect;
+export type NewCommonCode = typeof common_codes.$inferInsert;