@anchrd/colab-sdk 0.1.7 → 0.1.9

package/dist/boards/boards.js

@@ -68,16 +68,16 @@ export const BoardUpdateInput = z.strictObject({
         .optional()
         .describe("The board's labels, all of them: a label with labelId is kept or renamed, one without is made, and a label left out is removed from the board and from every task carrying it."),
 });
-export const BoardColumn = z.strictObject({
+export const BoardColumn = z.object({
     columnId: ColumnId,
     name: z.string(),
     type: ColumnType,
     visible: z.boolean(),
 });
-export const BoardLabel = z.strictObject({ labelId: LabelId, name: z.string() });
+export const BoardLabel = z.object({ labelId: LabelId, name: z.string() });
 // What stands between a board and saving it as a process (#43): the UI shows a box for each, and the
 // server refuses on its own (trap P066).
-export const ProcessCheck = z.strictObject({
+export const ProcessCheck = z.object({
     // A machine (an Operator) holds write on the board (#334: any machine, whatever its roles).
     operator: z.boolean(),
     // The first column is of type backlog.
@@ -87,9 +87,9 @@ export const ProcessCheck = z.strictObject({
     // Every machine that is neither locked nor archived, whatever its roles, by name (#148, #334):
     // whom the settings offer "Für Operator freigeben". Empty when there is none. Readable with the board,
     // without any right in `access`.
-    operators: z.array(z.strictObject({ userId: z.string(), name: z.string() })),
+    operators: z.array(z.object({ userId: z.string(), name: z.string() })),
 });
-export const BoardDetail = z.strictObject({
+export const BoardDetail = z.object({
     boardId: NodeId,
     name: z.string(),
     kind: BoardShownKind,
@@ -109,7 +109,7 @@ export const BoardDetail = z.strictObject({
     validator: NodePerson.nullable(),
     columns: z.array(BoardColumn),
     labels: z.array(BoardLabel),
-    rights: z.strictObject({ write: z.boolean() }),
+    rights: z.object({ write: z.boolean() }),
     rev: z.number().int(),
     updatedAt: z.iso.datetime(),
 });
@@ -204,10 +204,10 @@ export const TaskUpdateInput = z.strictObject({
 });
 // An image linked in a task's content: an outside URL, or a file in Colab the caller can read.
 export const TaskImage = z.union([
-    z.strictObject({ kind: z.literal("url"), url: z.string() }),
-    z.strictObject({ kind: z.literal("file"), nodeId: NodeId }),
+    z.object({ kind: z.literal("url"), url: z.string() }),
+    z.object({ kind: z.literal("file"), nodeId: NodeId }),
 ]);
-export const BoardTaskItem = z.strictObject({
+export const BoardTaskItem = z.object({
     taskId: NodeId,
     // The run the task belongs to, null for a task of the board itself (the template of a process).
     runId: RunRef.nullable(),
@@ -228,20 +228,20 @@ export const BoardTaskItem = z.strictObject({
     // Whether the caller may change this task, as intelligence_task_update decides it: the board's
     // right for a task, its node's for a ticket (#47: the node's responsible person, the holder of
     // `validator` (#334), an admin in admin mode; only reading while the node is archived).
-    rights: z.strictObject({ write: z.boolean() }),
+    rights: z.object({ write: z.boolean() }),
     position: z.string(),
     rev: z.number().int(),
     updatedAt: z.iso.datetime(),
 });
-export const BoardTaskList = z.strictObject({
+export const BoardTaskList = z.object({
     items: z.array(BoardTaskItem),
     nextCursor: z.string().nullable(),
     // Over MCP only (E87, #354): the board's instruction, a run's copy of it with `runId`; null
     // without one.
     instruction: z.string().nullable().optional(),
 });
-const TaskRef = z.strictObject({ taskId: NodeId, title: z.string(), column: TaskColumn });
-export const TaskDetail = z.strictObject({
+const TaskRef = z.object({ taskId: NodeId, title: z.string(), column: TaskColumn });
+export const TaskDetail = z.object({
     taskId: NodeId,
     boardId: NodeId,
     runId: RunRef.nullable(),
@@ -257,12 +257,12 @@ export const TaskDetail = z.strictObject({
     parentTaskId: NodeId.nullable(),
     position: z.string(),
     // The crumbs: the board with what board it is (its icon, #385), then every task above it, top down.
-    path: z.strictObject({
-        board: z.strictObject({ boardId: NodeId, name: z.string(), boardKind: BoardShownKind }),
-        tasks: z.array(z.strictObject({ taskId: NodeId, title: z.string() })),
+    path: z.object({
+        board: z.object({ boardId: NodeId, name: z.string(), boardKind: BoardShownKind }),
+        tasks: z.array(z.object({ taskId: NodeId, title: z.string() })),
     }),
     // The direct subtasks, and how many of them are done.
-    subtasks: z.strictObject({
+    subtasks: z.object({
         items: z.array(TaskRef),
         done: z.number().int(),
         total: z.number().int(),
@@ -270,10 +270,10 @@ export const TaskDetail = z.strictObject({
     dependencies: z.array(TaskRef),
     ready: z.boolean(),
     images: z.array(TaskImage),
-    rights: z.strictObject({ write: z.boolean() }),
+    rights: z.object({ write: z.boolean() }),
     // The task waits (#377, E77): its assignee lacks something, a right above all, and asked in the
     // chat. Shown in place of the column; null while it does not wait.
-    waiting: z.strictObject({ since: z.iso.datetime(), by: NodePerson }).nullable(),
+    waiting: z.object({ since: z.iso.datetime(), by: NodePerson }).nullable(),
     // A ticket of the validation board (#47): the node it validates with its path, and every move,
     // newest first. Both null for every other task.
     subject: TicketSubject.nullable(),

package/dist/columns/columns.d.ts

@@ -24,5 +24,5 @@ export declare const TaskColumn: z.ZodObject<{
         blocked: "blocked";
         archive: "archive";
     }>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type TaskColumn = z.infer<typeof TaskColumn>;

package/dist/columns/columns.js

@@ -21,7 +21,7 @@ export const columnTypes = [
 export const ColumnType = z
     .enum(columnTypes)
     .describe("What a column means: backlog (not ready yet), open (waiting), progress (being worked on), done (closed with yes), discarded (closed with no: rejected or lost, no error), blocked (an error), archive (the shelf at the bottom of every board, hidden by default).");
-export const TaskColumn = z.strictObject({
+export const TaskColumn = z.object({
     columnId: ColumnId,
     name: z.string(),
     type: ColumnType,

package/dist/connections/connections.d.ts

@@ -39,7 +39,7 @@ export type ConnectionRevokeInput = z.infer<typeof ConnectionRevokeInput>;
 export declare const ConnectionCredential: z.ZodObject<{
     name: z.ZodString;
     setAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ConnectionCredential = z.infer<typeof ConnectionCredential>;
 export declare const Connection: z.ZodObject<{
     connectorId: z.ZodString;
@@ -59,8 +59,8 @@ export declare const Connection: z.ZodObject<{
     credentials: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         setAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type Connection = z.infer<typeof Connection>;
 export declare const ConnectionDetail: z.ZodObject<{
     connectorId: z.ZodString;
@@ -80,9 +80,9 @@ export declare const ConnectionDetail: z.ZodObject<{
     credentials: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         setAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     settings: z.ZodRecord<z.ZodString, z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ConnectionDetail = z.infer<typeof ConnectionDetail>;
 export declare const ConnectionList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -103,18 +103,18 @@ export declare const ConnectionList: z.ZodObject<{
         credentials: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             setAt: z.ZodISODateTime;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ConnectionList = z.infer<typeof ConnectionList>;
 export declare const ConnectionTestResult: z.ZodDiscriminatedUnion<[z.ZodObject<{
     ok: z.ZodLiteral<true>;
     detail: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strip>, z.ZodObject<{
     ok: z.ZodLiteral<false>;
     error: z.ZodString;
-}, z.core.$strict>], "ok">;
+}, z.core.$strip>], "ok">;
 export type ConnectionTestResult = z.infer<typeof ConnectionTestResult>;
 export declare const ConnectionTested: z.ZodObject<{
     connection: z.ZodObject<{
@@ -135,15 +135,15 @@ export declare const ConnectionTested: z.ZodObject<{
         credentials: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             setAt: z.ZodISODateTime;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         settings: z.ZodRecord<z.ZodString, z.ZodString>;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     test: z.ZodDiscriminatedUnion<[z.ZodObject<{
         ok: z.ZodLiteral<true>;
         detail: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         ok: z.ZodLiteral<false>;
         error: z.ZodString;
-    }, z.core.$strict>], "ok">;
-}, z.core.$strict>;
+    }, z.core.$strip>], "ok">;
+}, z.core.$strip>;
 export type ConnectionTested = z.infer<typeof ConnectionTested>;

package/dist/connections/connections.js

@@ -35,12 +35,12 @@ export const ConnectionUpdateInput = z.strictObject({
 export const ConnectionTestInput = z.strictObject({ connectionId: ConnectionId });
 export const ConnectionRevokeInput = z.strictObject({ connectionId: ConnectionId });
 // A set secret: its field and when it was set, never its value.
-export const ConnectionCredential = z.strictObject({
+export const ConnectionCredential = z.object({
     name: z.string(),
     setAt: z.iso.datetime(),
 });
 // One connector's connection as the list shows it, also for a connector never connected.
-export const Connection = z.strictObject({
+export const Connection = z.object({
     connectorId: ConnectorId,
     // Null while the connector was never connected.
     connectionId: ConnectionId.nullable(),
@@ -58,17 +58,17 @@ export const Connection = z.strictObject({
     credentials: z.array(ConnectionCredential),
 });
 export const ConnectionDetail = Connection.extend({ settings: z.record(z.string(), z.string()) });
-export const ConnectionList = z.strictObject({
+export const ConnectionList = z.object({
     items: z.array(Connection),
     nextCursor: ConnectorId.nullable(),
 });
 // The connector's own test against its provider; an error is struck of every secret.
 export const ConnectionTestResult = z.discriminatedUnion("ok", [
-    z.strictObject({ ok: z.literal(true), detail: z.string().nullable() }),
-    z.strictObject({ ok: z.literal(false), error: z.string() }),
+    z.object({ ok: z.literal(true), detail: z.string().nullable() }),
+    z.object({ ok: z.literal(false), error: z.string() }),
 ]);
 // The answer of create, update and test: the connection after the test, and the test.
-export const ConnectionTested = z.strictObject({
+export const ConnectionTested = z.object({
     connection: ConnectionDetail,
     test: ConnectionTestResult,
 });

package/dist/connectors/connectors.d.ts

@@ -21,13 +21,13 @@ export declare const ConnectorField: z.ZodObject<{
         secret: "secret";
         setting: "setting";
     }>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ConnectorField = z.infer<typeof ConnectorField>;
 export declare const ConnectorTool: z.ZodObject<{
     function: z.ZodString;
     description: z.ZodString;
     writes: z.ZodBoolean;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ConnectorTool = z.infer<typeof ConnectorTool>;
 export declare const Connector: z.ZodObject<{
     connectorId: z.ZodString;
@@ -40,7 +40,7 @@ export declare const Connector: z.ZodObject<{
         function: z.ZodString;
         description: z.ZodString;
         writes: z.ZodBoolean;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     fields: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         label: z.ZodString;
@@ -51,8 +51,8 @@ export declare const Connector: z.ZodObject<{
             secret: "secret";
             setting: "setting";
         }>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type Connector = z.infer<typeof Connector>;
 export declare const ConnectorList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -66,7 +66,7 @@ export declare const ConnectorList: z.ZodObject<{
             function: z.ZodString;
             description: z.ZodString;
             writes: z.ZodBoolean;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         fields: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             label: z.ZodString;
@@ -77,10 +77,10 @@ export declare const ConnectorList: z.ZodObject<{
                 secret: "secret";
                 setting: "setting";
             }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type ConnectorList = z.infer<typeof ConnectorList>;
 export declare const CallSource: z.ZodEnum<{
     schedule: "schedule";
@@ -116,8 +116,8 @@ export declare const Call: z.ZodObject<{
             human: "human";
         }>>;
         image: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type Call = z.infer<typeof Call>;
 export declare const CallList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -141,8 +141,8 @@ export declare const CallList: z.ZodObject<{
                 human: "human";
             }>>;
             image: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`call_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type CallList = z.infer<typeof CallList>;

package/dist/connectors/connectors.js

@@ -16,7 +16,7 @@ export const ConnectorGetInput = z.strictObject({ connectorId: ConnectorId });
 //
 // ⚠️ Not `key` and not `secret: true`: `/mcp` strikes every value under a key that looks like a
 // secret (`redactSecrets` in `shared`), and both names match. `name` and `kind` survive it.
-export const ConnectorField = z.strictObject({
+export const ConnectorField = z.object({
     // The key in `settings` or `secrets`, `SHOPIFY_SHOP`.
     name: z.string(),
     label: z.string(),
@@ -25,13 +25,13 @@ export const ConnectorField = z.strictObject({
     optional: z.boolean(),
     kind: z.enum(["setting", "secret"]),
 });
-export const ConnectorTool = z.strictObject({
+export const ConnectorTool = z.object({
     // The key in the connector's `tools`, `order-list`; the right is `connectors / <id> / <function>`.
     function: z.string(),
     description: z.string(),
     writes: z.boolean(),
 });
-export const Connector = z.strictObject({
+export const Connector = z.object({
     connectorId: ConnectorId,
     name: z.string(),
     category: z.string(),
@@ -43,7 +43,7 @@ export const Connector = z.strictObject({
     tools: z.array(ConnectorTool),
     fields: z.array(ConnectorField),
 });
-export const ConnectorList = z.strictObject({
+export const ConnectorList = z.object({
     items: z.array(Connector),
     nextCursor: ConnectorId.nullable(),
 });
@@ -58,7 +58,7 @@ export const CallListInput = z.strictObject({
 });
 // One line of a connector's log: who, which function, the answer and how long it took, never the
 // arguments or the result (E69).
-export const Call = z.strictObject({
+export const Call = z.object({
     callId: CallId,
     connectorId: ConnectorId,
     // `order-list`, or `test` for the connection test.
@@ -72,7 +72,7 @@ export const Call = z.strictObject({
     // Null for the daily test, which nobody started. Name, kind and picture come from `access`, null
     // when it no longer knows the id; the picture is null for a machine and a person without one (#140).
     actor: z
-        .strictObject({
+        .object({
         userId: z.string(),
         name: z.string().nullable(),
         kind: z.enum(["human", "machine"]).nullable(),
@@ -80,4 +80,4 @@ export const Call = z.strictObject({
     })
         .nullable(),
 });
-export const CallList = z.strictObject({ items: z.array(Call), nextCursor: CallId.nullable() });
+export const CallList = z.object({ items: z.array(Call), nextCursor: CallId.nullable() });

package/dist/dashboards/dashboards.d.ts

@@ -210,12 +210,12 @@ export declare const DashboardDetail: z.ZodObject<{
     dueAt: z.ZodNullable<z.ZodISODateTime>;
     processCheck: z.ZodObject<{
         operator: z.ZodBoolean;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     rights: z.ZodObject<{
         write: z.ZodBoolean;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     rev: z.ZodNumber;
     updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type DashboardDetail = z.infer<typeof DashboardDetail>;
 export {};

package/dist/dashboards/dashboards.js

@@ -503,7 +503,7 @@ export const DashboardUpdateInput = z.strictObject({
     config: config.describe("The whole new configuration as an object, replacing the old one. Send exactly one of config and yaml."),
     yaml: yaml.describe("The whole new configuration as YAML text, replacing the old one; read it from intelligence_dashboard_get, change it, send it back. Send exactly one of config and yaml."),
 });
-export const DashboardDetail = z.strictObject({
+export const DashboardDetail = z.object({
     dashboardId: DashboardId,
     name: z.string(),
     config: DashboardConfig,
@@ -513,8 +513,8 @@ export const DashboardDetail = z.strictObject({
     // The moment a run is owed for now (passed, unanswered, no run open), else null.
     dueAt: z.iso.datetime().nullable(),
     // Whether a machine (an Operator) can write on it: a schedule other than manual needs one (#334).
-    processCheck: z.strictObject({ operator: z.boolean() }),
-    rights: z.strictObject({ write: z.boolean() }),
+    processCheck: z.object({ operator: z.boolean() }),
+    rights: z.object({ write: z.boolean() }),
     rev: z.number().int(),
     updatedAt: z.iso.datetime(),
 });

package/dist/directory/directory.d.ts

@@ -8,7 +8,7 @@ export declare const DirectoryPrincipal: z.ZodObject<{
     name: z.ZodString;
     email: z.ZodString;
     image: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type DirectoryPrincipal = z.infer<typeof DirectoryPrincipal>;
 export declare const DirectorySearchInput: z.ZodObject<{
     query: z.ZodString;

package/dist/directory/directory.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 // The directory (A24, E49, #26): who exists, for the @ menu and the share dialog. `access` answers it
 // in-process to the other packages; there is no HTTP door. The shape is here because the UI draws it.
-export const DirectoryPrincipal = z.strictObject({
+export const DirectoryPrincipal = z.object({
     userId: z.string(),
     kind: z.enum(["human", "machine"]),
     name: z.string(),

package/dist/documents/documents.d.ts

@@ -33,8 +33,8 @@ export declare const DocumentDetail: z.ZodObject<{
         items: z.ZodArray<z.ZodObject<{
             nodeId: z.ZodTemplateLiteral<`node_${string}`>;
             name: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
     content: z.ZodString;
     version: z.ZodNullable<z.ZodNumber>;
     savedAt: z.ZodNullable<z.ZodISODateTime>;
@@ -45,7 +45,7 @@ export declare const DocumentDetail: z.ZodObject<{
             machine: "machine";
             human: "human";
         }>>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     appHandle: z.ZodNullable<z.ZodString>;
     rev: z.ZodNumber;
     archivedAt: z.ZodNullable<z.ZodISODateTime>;
@@ -54,8 +54,8 @@ export declare const DocumentDetail: z.ZodObject<{
             path: z.ZodString;
             status: z.ZodNullable<z.ZodString>;
             markdown: z.ZodString;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         hint: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type DocumentDetail = z.infer<typeof DocumentDetail>;

package/dist/documents/documents.js

@@ -33,7 +33,7 @@ export const DocumentUpdateInput = z.strictObject({
         .optional()
         .describe("The editing session the editor keeps while a person stays on the document: saves of one session go into one version. Leaving it out makes every save a version of its own, which is right for an AI."),
 });
-export const DocumentDetail = z.strictObject({
+export const DocumentDetail = z.object({
     documentId: DocumentId,
     name: z.string(),
     hidden: z.boolean(),

package/dist/events/events.d.ts

@@ -52,7 +52,7 @@ export declare const Event: z.ZodObject<{
     target: z.ZodNullable<z.ZodObject<{
         id: z.ZodString;
         name: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     actor: z.ZodNullable<z.ZodObject<{
         userId: z.ZodString;
         name: z.ZodNullable<z.ZodString>;
@@ -62,12 +62,12 @@ export declare const Event: z.ZodObject<{
             human: "human";
         }>>;
         image: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     failed: z.ZodBoolean;
     code: z.ZodNullable<z.ZodString>;
     ip: z.ZodNullable<z.ZodString>;
     detail: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Event = z.infer<typeof Event>;
 export declare const EventList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
@@ -83,7 +83,7 @@ export declare const EventList: z.ZodObject<{
         target: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         actor: z.ZodNullable<z.ZodObject<{
             userId: z.ZodString;
             name: z.ZodNullable<z.ZodString>;
@@ -93,12 +93,12 @@ export declare const EventList: z.ZodObject<{
                 human: "human";
             }>>;
             image: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>;
+        }, z.core.$strip>>;
         failed: z.ZodBoolean;
         code: z.ZodNullable<z.ZodString>;
         ip: z.ZodNullable<z.ZodString>;
         detail: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodTemplateLiteral<`event_${string}`>>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type EventList = z.infer<typeof EventList>;

package/dist/events/events.js

@@ -37,7 +37,7 @@ export const EventListInput = z.strictObject({
     cursor: EventId.optional(),
     limit: Limit.optional(),
 });
-export const Event = z.strictObject({
+export const Event = z.object({
     eventId: EventId,
     createdAt: z.iso.datetime(),
     // `resource.action`: `role.update`, `session.create` (a sign-in).
@@ -45,14 +45,14 @@ export const Event = z.strictObject({
     kind: EventKind,
     // The name is the one at the time of the event: after a rename or a removal it is still the name
     // the event was about.
-    target: z.strictObject({ id: z.string(), name: z.string().nullable() }).nullable(),
+    target: z.object({ id: z.string(), name: z.string().nullable() }).nullable(),
     // Null for an anonymous attempt (a failed sign-in) and for what Colab does itself (a cleanup).
     // Name and kind are null when the id no longer names anybody. `image` is the person's picture as
     // `access.directory.resolve` gives it: null for a machine, a service and a person without one
     // (#140). ⚠️ `userId` also carries a `service_…` id when `kind` is `service` (#178): the field
     // keeps its name so the answer's shape stays as the UI reads it.
     actor: z
-        .strictObject({
+        .object({
         userId: z.string(),
         name: z.string().nullable(),
         kind: ActorKind.nullable(),
@@ -66,4 +66,4 @@ export const Event = z.strictObject({
     ip: z.string().nullable(),
     detail: z.record(z.string(), z.unknown()).nullable(),
 });
-export const EventList = z.strictObject({ items: z.array(Event), nextCursor: EventId.nullable() });
+export const EventList = z.object({ items: z.array(Event), nextCursor: EventId.nullable() });

package/dist/files/files.d.ts

@@ -34,7 +34,7 @@ export declare const UploadTicket: z.ZodObject<{
     ticket: z.ZodString;
     expiresAt: z.ZodISODateTime;
     curl: z.ZodString;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type UploadTicket = z.infer<typeof UploadTicket>;
 export declare const FileUpload: z.ZodObject<{
     upload: z.ZodObject<{
@@ -42,9 +42,17 @@ export declare const FileUpload: z.ZodObject<{
         ticket: z.ZodString;
         expiresAt: z.ZodISODateTime;
         curl: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type FileUpload = z.infer<typeof FileUpload>;
+export declare const fileTextStates: readonly ["reading", "done", "failed", "none"];
+export declare const FileTextState: z.ZodEnum<{
+    done: "done";
+    failed: "failed";
+    reading: "reading";
+    none: "none";
+}>;
+export type FileTextState = z.infer<typeof FileTextState>;
 export declare const FileDetail: z.ZodObject<{
     fileId: z.ZodTemplateLiteral<`node_${string}`>;
     name: z.ZodString;
@@ -54,11 +62,17 @@ export declare const FileDetail: z.ZodObject<{
     version: z.ZodObject<{
         versionId: z.ZodTemplateLiteral<`version_${string}`>;
         number: z.ZodNumber;
-    }, z.core.$strict>;
+    }, z.core.$strip>;
     rev: z.ZodNumber;
     text: z.ZodNullable<z.ZodString>;
+    textState: z.ZodEnum<{
+        done: "done";
+        failed: "failed";
+        reading: "reading";
+        none: "none";
+    }>;
     contentUrl: z.ZodURL;
     sourceUrl: z.ZodOptional<z.ZodString>;
     fetchedAt: z.ZodOptional<z.ZodISODateTime>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type FileDetail = z.infer<typeof FileDetail>;

package/dist/files/files.js

@@ -146,16 +146,22 @@ export const FileGetInput = z.strictObject({ fileId: FileId });
 // What `_create` and `_update` answer: the door, the ticket and the whole command. ⚠️ `ticket` is a
 // credential, and it is in this answer on purpose: it opens ONE upload for ONE person for fifteen
 // minutes. It appears nowhere else, never in an error and never in a log.
-export const UploadTicket = z.strictObject({
+export const UploadTicket = z.object({
     url: z.url(),
     ticket: z.string().min(1),
     expiresAt: z.iso.datetime(),
     // A shell command that sends the file; the path to the file is the one placeholder left.
     curl: z.string().min(1),
 });
-export const FileUpload = z.strictObject({ upload: UploadTicket });
+export const FileUpload = z.object({ upload: UploadTicket });
+// Where the text of a file's current version stands (#553): `reading` while the queue `index` reads
+// it, `done` once `text` holds it, `failed` once the last attempt failed (search then finds the file
+// by its name only), `none` for a file without text (an image, a ZIP, or a format the converter
+// does not run for, as locally).
+export const fileTextStates = ["reading", "done", "failed", "none"];
+export const FileTextState = z.enum(fileTextStates);
 // A file as `_get` and the upload door answer it, always about its current version.
-export const FileDetail = z.strictObject({
+export const FileDetail = z.object({
     fileId: FileId,
     // The node's name, as the tree shows it.
     name: z.string(),
@@ -163,12 +169,12 @@ export const FileDetail = z.strictObject({
     fileName: z.string(),
     mediaType: z.string(),
     size: z.number().int(),
-    version: z.strictObject({ versionId: VersionId, number: z.number().int() }),
+    version: z.object({ versionId: VersionId, number: z.number().int() }),
     // The node's revision, to send with the next `_update`.
     rev: z.number().int(),
-    // The text read from the current version for search and AI; null while it is being read, and for
-    // a file without text (an image, a ZIP).
+    // The text read from the current version for search and AI; null unless `textState` is `done`.
     text: z.string().nullable(),
+    textState: FileTextState,
     // Where the bytes are read, with a session or a token and the right to read the file.
     contentUrl: z.url(),
     // Only on a version Colab fetched from an address (#556): the address asked for and when.