@carthooks/arcubase-cli 0.1.2 → 0.1.4

package/dist/runtime/entity_save_schema.js

@@ -0,0 +1,641 @@
+import { z } from 'zod';
+import { EntityOptionsSchema, EntitySerialUpdaterVOSchema } from '../generated/zod_registry.generated.js';
+const simpleFieldTypes = [
+    'text',
+    'textarea',
+    'number',
+    'datetime',
+    'boolean',
+    'button',
+    'address',
+    'datasets',
+    'department',
+    'departments',
+    'divider',
+    'file',
+    'image',
+    'location',
+    'member',
+    'members',
+    'signature',
+    'tags',
+    'workflow_status',
+    'mobile',
+];
+const enumFieldTypes = ['select', 'selects', 'radio', 'checkbox', 'status'];
+const relationFieldTypes = ['linkto', 'relation', 'query'];
+const strictFieldTypes = new Set([
+    ...simpleFieldTypes,
+    ...enumFieldTypes,
+    ...relationFieldTypes,
+    'formula',
+    'lookup',
+    'relationfield',
+    'rollup',
+    'serialnumber',
+    'subform',
+]);
+const relationTypeSchema = z.union([z.literal('entity'), z.literal('aggregation')]);
+const linkModeSchema = z.union([z.literal('manual'), z.literal('auto')]);
+const linkStructureSchema = z.union([z.literal('single'), z.literal('multiple')]);
+const enumItemSchema = z.object({
+    key: z.union([z.number(), z.string()]).optional(),
+    value: z.string().min(1),
+}).passthrough();
+const statusItemSchema = z.object({
+    key: z.union([z.number(), z.string()]).optional(),
+    code: z.union([z.number(), z.string()]),
+    value: z.string().min(1),
+}).passthrough();
+const sortConfigSchema = z.object({
+    column: z.string().min(1),
+    order: z.union([z.literal('asc'), z.literal('desc')]),
+}).strict();
+const relationOptionsSchema = z.object({
+    entity_id: z.number().int().positive(),
+    app_id: z.number().int().positive(),
+    type: relationTypeSchema,
+    show_fields: z.array(z.number().int().positive()).optional(),
+    condition: z.record(z.string(), z.any()).optional(),
+    sorts: z.array(sortConfigSchema).optional(),
+    queryFields: z.array(z.number().int().positive()).optional(),
+    subform_id: z.number().int().positive().optional(),
+}).strict();
+const lookupRelationSchema = z.object({
+    local_linkto_field_id: z.number().int().min(1001),
+    target_field_id: z.number().int().min(1001),
+    target_field_type: z.string().min(1),
+}).strict();
+const relationFieldRelationSchema = z.object({
+    app_id: z.number().int().positive(),
+    entity_id: z.number().int().positive(),
+    type: relationTypeSchema.optional(),
+    show_fields: z.array(z.number().int().positive()).optional(),
+    condition: z.record(z.string(), z.any()).optional(),
+    sorts: z.array(sortConfigSchema).optional(),
+    queryFields: z.array(z.number().int().positive()).optional(),
+    subform_id: z.number().int().positive().optional(),
+}).strict();
+const formulaSchema = z.object({
+    code: z.string().min(1),
+    jsonlogic: z.record(z.string(), z.any()),
+}).strict();
+const serialPartBuildinStringSchema = z.object({
+    mode: z.literal('buildin'),
+    type: z.literal('string'),
+    options: z.object({
+        value: z.string(),
+    }).strict(),
+}).strict();
+const serialPartBuildinDateSchema = z.object({
+    mode: z.literal('buildin'),
+    type: z.literal('date'),
+    options: z.object({
+        format: z.string().optional(),
+        perdefined: z.boolean().optional(),
+        perdefinedFormat: z.string().optional(),
+    }).strict().refine((value) => Boolean(value.format || value.perdefinedFormat), {
+        message: 'date serial part requires format or perdefinedFormat',
+    }),
+}).strict();
+const serialPartBuildinSerialSchema = z.object({
+    mode: z.literal('buildin'),
+    type: z.literal('serial'),
+    options: z.object({
+        length: z.number().int().min(1),
+        lenfixed: z.boolean().optional(),
+        random: z.boolean().optional(),
+        reset: z.string().optional(),
+    }).strict(),
+}).strict();
+const serialPartFieldSchema = z.object({
+    mode: z.literal('field'),
+    field_id: z.number().int().min(1001),
+}).passthrough();
+const serialPartSchema = z.union([
+    serialPartBuildinStringSchema,
+    serialPartBuildinDateSchema,
+    serialPartBuildinSerialSchema,
+    serialPartFieldSchema,
+]);
+const fieldCommonShape = {
+    id: z.number().int().min(1001),
+    label: z.string().min(1),
+    required: z.boolean(),
+    unique: z.boolean(),
+    editable: z.boolean(),
+    visible: z.boolean(),
+    show_label: z.boolean(),
+    scannable: z.boolean(),
+    default_value_mode: z.number(),
+    description: z.string(),
+    value: z.any(),
+    number_decimal: z.number().int().min(0),
+    depends: z.array(z.number().int().min(1001)),
+    key: z.string(),
+    code_index: z.boolean(),
+    transfers: z.array(z.any()).nullable(),
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneJSON(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function makeSimpleFieldSchema(type) {
+    return z.object({
+        ...fieldCommonShape,
+        type: z.literal(type),
+        options: z.record(z.string(), z.any()).nullable(),
+        children: z.null(),
+    }).strict();
+}
+function makeEnumFieldSchema(type) {
+    const itemSchema = type === 'status' ? statusItemSchema : enumItemSchema;
+    return z.object({
+        ...fieldCommonShape,
+        type: z.literal(type),
+        options: z.object({
+            options: z.object({
+                items: z.array(itemSchema).min(1),
+            }).passthrough(),
+        }).passthrough(),
+        children: z.null(),
+    }).strict();
+}
+const simpleFieldSchemas = simpleFieldTypes.map((type) => makeSimpleFieldSchema(type));
+const enumFieldSchemas = enumFieldTypes.map((type) => makeEnumFieldSchema(type));
+const formulaFieldSchema = z.object({
+    ...fieldCommonShape,
+    type: z.literal('formula'),
+    options: z.object({
+        formula: formulaSchema,
+    }).passthrough(),
+    children: z.null(),
+}).strict();
+const relationFieldSchemas = relationFieldTypes.map((type) => z.object({
+    ...fieldCommonShape,
+    type: z.literal(type),
+    options: z.object({
+        relation: relationOptionsSchema,
+        mode: linkModeSchema.optional(),
+        structure: linkStructureSchema.optional(),
+        multiple: z.boolean().optional(),
+        backfill: z.array(z.object({
+            id: z.number().int().min(1001),
+            local_id: z.number().int().min(1001),
+        }).strict()).optional(),
+        addValue: z.boolean().optional(),
+        placeholder: z.string().optional(),
+    }).passthrough(),
+    children: z.null(),
+}).strict());
+const lookupFieldSchema = z.object({
+    ...fieldCommonShape,
+    type: z.literal('lookup'),
+    options: z.object({
+        relation: lookupRelationSchema,
+    }).passthrough(),
+    children: z.null(),
+}).strict();
+const relationFieldFieldSchema = z.object({
+    ...fieldCommonShape,
+    type: z.literal('relationfield'),
+    options: z.object({
+        relation: relationFieldRelationSchema,
+    }).passthrough(),
+    children: z.null(),
+}).strict();
+const rollupFieldSchema = z.object({
+    ...fieldCommonShape,
+    type: z.literal('rollup'),
+    options: z.object({
+        relation: lookupRelationSchema,
+        aggregation_formula: formulaSchema,
+    }).passthrough(),
+    children: z.null(),
+}).strict();
+const serialNumberFieldSchema = z.object({
+    ...fieldCommonShape,
+    type: z.literal('serialnumber'),
+    options: z.object({
+        parts: z.array(serialPartSchema).min(1),
+    }).passthrough(),
+    children: z.null(),
+}).strict();
+const genericFieldSchema = z.object({
+    ...fieldCommonShape,
+    type: z.string().min(1).refine((value) => !strictFieldTypes.has(value), {
+        message: 'known field type must use dedicated schema',
+    }),
+    options: z.record(z.string(), z.any()).nullable(),
+    children: z.null(),
+}).strict();
+const baseFieldSchemaVariants = [
+    ...simpleFieldSchemas,
+    ...enumFieldSchemas,
+    ...relationFieldSchemas,
+    formulaFieldSchema,
+    lookupFieldSchema,
+    relationFieldFieldSchema,
+    rollupFieldSchema,
+    serialNumberFieldSchema,
+    genericFieldSchema,
+];
+export const BaseFieldSchema = z.union(baseFieldSchemaVariants);
+export const SubformFieldSchema = z.lazy(() => z.object({
+    ...fieldCommonShape,
+    type: z.literal('subform'),
+    options: z.record(z.string(), z.any()).nullable(),
+    children: z.array(BaseFieldSchema),
+    layout: z.array(z.array(z.number().int().min(1001))).optional(),
+}).strict());
+export const FieldVOSchema = z.lazy(() => z.union([
+    SubformFieldSchema,
+    BaseFieldSchema,
+]));
+function normalizeEntitySaveInput(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const entity = cloneJSON(value);
+    if (entity.layout === null) {
+        entity.layout = [];
+    }
+    if (entity.current_serial === null) {
+        delete entity.current_serial;
+    }
+    if (isRecord(entity.options)) {
+        if (entity.options.Buttons === null) {
+            entity.options.Buttons = [];
+        }
+        if (entity.options.CustomActions === null) {
+            entity.options.CustomActions = [];
+        }
+        if (entity.options.FrontendEvents === null) {
+            entity.options.FrontendEvents = [];
+        }
+        if (entity.options.misc === null) {
+            entity.options.misc = {};
+        }
+        if (isRecord(entity.options.TitleFormat)) {
+            if (entity.options.TitleFormat.Fields === null) {
+                entity.options.TitleFormat.Fields = [];
+            }
+            if (entity.options.TitleFormat.Parts === null) {
+                entity.options.TitleFormat.Parts = [];
+            }
+        }
+    }
+    return entity;
+}
+function collectAllFieldIds(fields) {
+    const out = [];
+    for (const field of fields) {
+        out.push(field.id);
+        if (field.type === 'subform' && Array.isArray(field.children)) {
+            for (const child of field.children) {
+                out.push(child.id);
+            }
+        }
+    }
+    return out;
+}
+function collectTopLevelFieldIds(fields) {
+    return fields.map((field) => field.id);
+}
+function extractFormulaFieldIds(value) {
+    if (!value || typeof value !== 'string')
+        return [];
+    const ids = [...value.matchAll(/:(\d+)\]\]/g)].map((match) => Number(match[1]));
+    return ids.filter((id) => Number.isInteger(id) && id > 0);
+}
+const EntitySaveReqVOBaseSchema = z.object({
+    app_id: z.number().optional(),
+    current_serial: EntitySerialUpdaterVOSchema.optional(),
+    field_id_seq: z.number().int(),
+    fields: z.array(FieldVOSchema),
+    id: z.number().optional(),
+    layout: z.array(z.array(z.number().int().min(1001))).optional(),
+    name: z.string().optional(),
+    options: EntityOptionsSchema.optional(),
+    prototypes: z.array(z.number()).optional(),
+    schema_version: z.number().optional(),
+    workflow_enabled: z.boolean().optional(),
+}).strict().superRefine((entity, ctx) => {
+    const fields = entity.fields;
+    const topLevelIds = new Set(collectTopLevelFieldIds(fields));
+    const allIds = collectAllFieldIds(fields);
+    const allIdSet = new Set();
+    for (const id of allIds) {
+        if (allIdSet.has(id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['fields'],
+                message: `duplicate field id: ${id}`,
+            });
+        }
+        allIdSet.add(id);
+    }
+    const maxFieldId = allIds.length > 0 ? Math.max(...allIds) : 1000;
+    if (entity.field_id_seq <= maxFieldId) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['field_id_seq'],
+            message: `field_id_seq must be greater than max field id ${maxFieldId}`,
+        });
+    }
+    for (const [rowIndex, row] of (entity.layout ?? []).entries()) {
+        for (const [colIndex, fieldId] of row.entries()) {
+            if (!topLevelIds.has(fieldId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['layout', rowIndex, colIndex],
+                    message: `layout references unknown top-level field id ${fieldId}`,
+                });
+            }
+        }
+    }
+    for (const [fieldIndex, field] of fields.entries()) {
+        if (field.type !== 'subform' && field.children !== null) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['fields', fieldIndex, 'children'],
+                message: 'only subform field can define children',
+            });
+        }
+        if (field.type === 'subform') {
+            const childIds = new Set((field.children ?? []).map((child) => child.id));
+            for (const [rowIndex, row] of (field.layout ?? []).entries()) {
+                for (const [colIndex, fieldId] of row.entries()) {
+                    if (!childIds.has(fieldId)) {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.custom,
+                            path: ['fields', fieldIndex, 'layout', rowIndex, colIndex],
+                            message: `subform layout references non-child field id ${fieldId}`,
+                        });
+                    }
+                }
+            }
+        }
+        if (field.type === 'lookup' || field.type === 'rollup') {
+            const localLinktoFieldId = field.options?.relation?.local_linkto_field_id;
+            if (typeof localLinktoFieldId === 'number') {
+                const target = fields.find((item) => item.id === localLinktoFieldId);
+                if (!target || target.type !== 'linkto') {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ['fields', fieldIndex, 'options', 'relation', 'local_linkto_field_id'],
+                        message: 'local_linkto_field_id must reference a linkto field',
+                    });
+                }
+            }
+        }
+        if (field.type === 'formula' || field.type === 'rollup') {
+            const formulaCode = field.type === 'formula'
+                ? field.options?.formula?.code
+                : field.options?.aggregation_formula?.code;
+            for (const referencedFieldId of extractFormulaFieldIds(formulaCode)) {
+                if (!allIdSet.has(referencedFieldId)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ['fields', fieldIndex, 'options'],
+                        message: `formula references unknown field id ${referencedFieldId}`,
+                    });
+                }
+            }
+        }
+    }
+});
+export const EntitySaveReqVOSchemaOverride = z.preprocess(normalizeEntitySaveInput, EntitySaveReqVOBaseSchema);
+const queryOrderSchema = z.object({
+    column: z.string().min(1),
+    order: z.string().min(1),
+}).strict();
+export const AppCreateByTenantsReqVOSchemaOverride = z.object({
+    icon_color: z.string().optional(),
+    icon_name: z.string().optional(),
+    name: z.string().min(1).max(20),
+}).strict();
+export const EntityQueryReqVOSchemaOverride = z.object({
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().min(0).optional(),
+    policy_id: z.string().optional(),
+    search: z.record(z.string(), z.any()).optional(),
+    sorts: z.array(queryOrderSchema).optional(),
+    view_mode: z.string().optional(),
+    viewMode: z.never().optional(),
+    withSubForm: z.boolean().optional(),
+}).strict();
+export const InsertReqVOSchemaOverride = z.object({
+    policy_id: z.string().optional(),
+    fields: z.record(z.string(), z.any()),
+}).strict().superRefine((body, ctx) => {
+    for (const key of Object.keys(body.fields ?? {})) {
+        if (!/^\d+$/.test(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['fields', key],
+                message: 'row fields must use numeric field ids as keys',
+            });
+        }
+    }
+});
+export const EntityUpdateReqVOSchemaOverride = z.object({
+    changed_fields: z.array(z.number().int().positive()).min(1),
+    data: z.record(z.string(), z.any()),
+    policy_id: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    fields: z.never().optional(),
+}).strict().superRefine((body, ctx) => {
+    const dataFieldIds = new Set();
+    for (const key of Object.keys(body.data ?? {})) {
+        if (!/^\d+$/.test(key)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['data', key],
+                message: 'row data must use numeric field ids as keys',
+            });
+            continue;
+        }
+        dataFieldIds.add(Number(key));
+    }
+    for (const [index, fieldId] of body.changed_fields.entries()) {
+        if (!dataFieldIds.has(fieldId)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['changed_fields', index],
+                message: `changed_fields references ${fieldId}, but data does not contain that field id`,
+            });
+        }
+    }
+});
+const entitySelectionSortSchema = z.object({
+    column: z.string().min(1),
+    order: z.string().min(1),
+}).strict();
+const entitySelectionIdsSchema = z.object({
+    type: z.literal('ids'),
+    ids: z.array(z.number().int().positive()).min(1),
+    length: z.number().int().positive().optional(),
+    sorts: z.array(entitySelectionSortSchema).optional(),
+    condition: z.record(z.string(), z.any()).optional(),
+}).strict().superRefine((selection, ctx) => {
+    if (selection.length !== undefined && selection.length !== selection.ids.length) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['length'],
+            message: 'length must match ids.length when provided',
+        });
+    }
+});
+const entitySelectionConditionSchema = z.object({
+    type: z.literal('condition'),
+    length: z.number().int().positive(),
+    condition: z.record(z.string(), z.any()).superRefine((condition, ctx) => {
+        if (!Object.keys(condition).length) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'condition selection requires a non-empty condition object',
+            });
+            return;
+        }
+        if (condition.selectAll !== true) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['selectAll'],
+                message: 'condition selection must set selectAll to true',
+            });
+        }
+        const filterKeys = Object.keys(condition).filter((key) => key !== 'selectAll');
+        if (filterKeys.length === 0) {
+            return;
+        }
+        const hasSupportedQueryKey = filterKeys.some((key) => key === 'q' || key === 'tab' || key.startsWith('filter_'));
+        if (!hasSupportedQueryKey) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'condition selection extra keys must use q, tab, or filter_*',
+            });
+        }
+    }),
+    sorts: z.array(entitySelectionSortSchema).optional(),
+    ids: z.array(z.number().int().positive()).optional(),
+}).strict();
+const entitySelectionAllSchema = z.object({
+    type: z.literal('all'),
+    length: z.number().int().positive().optional(),
+    ids: z.array(z.number().int().positive()).optional(),
+    condition: z.record(z.string(), z.any()).optional(),
+    sorts: z.array(entitySelectionSortSchema).optional(),
+}).strict();
+const entitySelectionSchema = z.union([
+    entitySelectionIdsSchema,
+    entitySelectionConditionSchema,
+    entitySelectionAllSchema,
+]);
+const entitySelectionLooseSchema = z.union([
+    entitySelectionSchema,
+    entitySelectionAllSchema,
+]);
+export const EntitySelectionActionReqVOSchemaOverride = z.lazy(() => z.object({
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().min(0).optional(),
+    policy_id: z.string().optional(),
+    selection: entitySelectionSchema,
+}).strict());
+const bulkUpdateActionSchema = z.object({
+    type: z.string().min(1),
+    value: z.any().optional(),
+    text_search: z.string().optional(),
+    text_replace: z.string().optional(),
+    text_append: z.string().optional(),
+    text_prepend: z.string().optional(),
+    number_add: z.number().optional(),
+    number_mul: z.number().optional(),
+    number_sub: z.number().optional(),
+    datetime_add: z.number().optional(),
+    datetime_sub: z.number().optional(),
+}).strict().superRefine((action, ctx) => {
+    switch (action.type) {
+        case 'set':
+            if (!('value' in action)) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['value'], message: 'set action requires value' });
+            }
+            break;
+        case 'text_replace':
+            if (!action.text_search) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_search'], message: 'text_replace requires text_search' });
+            }
+            if (!action.text_replace) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_replace'], message: 'text_replace requires text_replace' });
+            }
+            break;
+        case 'text_append':
+            if (!action.text_append) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_append'], message: 'text_append requires text_append' });
+            }
+            break;
+        case 'text_prepend':
+            if (!action.text_prepend) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_prepend'], message: 'text_prepend requires text_prepend' });
+            }
+            break;
+        case 'number_add':
+            if (typeof action.number_add !== 'number') {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['number_add'], message: 'number_add requires number_add' });
+            }
+            break;
+        case 'number_sub':
+            if (typeof action.number_sub !== 'number') {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['number_sub'], message: 'number_sub requires number_sub' });
+            }
+            break;
+        case 'number_mul':
+            if (typeof action.number_mul !== 'number') {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['number_mul'], message: 'number_mul requires number_mul' });
+            }
+            break;
+        case 'datetime_add':
+            if (typeof action.datetime_add !== 'number') {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['datetime_add'], message: 'datetime_add requires datetime_add' });
+            }
+            break;
+        case 'datetime_sub':
+            if (typeof action.datetime_sub !== 'number') {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['datetime_sub'], message: 'datetime_sub requires datetime_sub' });
+            }
+            break;
+        case 'datetime_now':
+        case 'formula':
+            break;
+        default:
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['type'], message: `unsupported bulk update action type: ${action.type}` });
+    }
+});
+export const EntityBulkUpdateReqVOSchemaOverride = z.object({
+    policy_id: z.string().optional(),
+    selection: entitySelectionSchema,
+    fields: z.array(z.object({
+        id: z.number().int().min(1001),
+        action: bulkUpdateActionSchema,
+    }).strict()).min(1),
+}).strict();
+export const EntityTagsSelectionReqVOSchemaOverride = z.object({
+    policy_id: z.string(),
+    selection: entitySelectionSchema,
+}).strict();
+export const EntityTagsBatchReqVOSchemaOverride = z.object({
+    policy_id: z.string(),
+    selection: entitySelectionSchema,
+    tag_names: z.array(z.string().min(1)).min(1),
+}).strict();
+export const EntityInvokeBatchOperatorReqVOSchemaOverride = z.object({
+    id: z.string().min(1),
+    data: z.object({
+        action_id: z.string().min(1),
+        policy_id: z.string().optional(),
+        selection: entitySelectionLooseSchema,
+    }).strict(),
+    params: z.record(z.string(), z.any()).optional(),
+}).strict();

package/dist/runtime/errors.d.ts

@@ -6,12 +6,23 @@ export type CLITSTypeHint = {
     symbol: string;
     file: string;
 };
+export type CLIDocHint = {
+    title: string;
+    file: string;
+};
 export type CLIErrorDetails = {
     operation?: string;
     requestType?: string;
     issues?: CLIValidationIssue[];
     tsHints?: CLITSTypeHint[];
+    docHints?: CLIDocHint[];
     reason?: string;
+    hint?: string;
+    endpoint?: string;
+    method?: string;
+    traceId?: string;
+    upstreamError?: unknown;
+    suggestions?: string[];
 };
 export declare class CLIError extends Error {
     readonly code: string;

package/dist/runtime/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC7B,OAAO,CAAC,EAAE,aAAa,EAAE,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAA;gBAEtB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,OAAO,CAAC,EAAE,eAAe;IAQlF,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CASlC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAC7B,OAAO,CAAC,EAAE,aAAa,EAAE,CAAA;IACzB,QAAQ,CAAC,EAAE,UAAU,EAAE,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;CACvB,CAAA;AAED,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,CAAA;gBAEtB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,OAAO,CAAC,EAAE,eAAe;IAQlF,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CASlC"}

package/dist/runtime/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/runtime/execute.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1D,OAAO,EAAgD,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIvG,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,YAAY,CAAA;IACnB,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IAC5B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAQ1D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAWhF;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAatG;AA8CD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,uBAAuB,CActH;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,UAAkC,EAAE,SAAS,GAAE,OAAO,KAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAyF5J"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/runtime/execute.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,UAAU,CAAA;AAG1D,OAAO,EAAwE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAK/H,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,YAAY,CAAA;IACnB,WAAW,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;IAC5B,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AAYD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAa1D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAehF;AAcD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CA6BtG;AA8RD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,uBAAuB,CActH;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,SAAS,GAAE,OAAO,KAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CA4JrI"}