@withmestra/sdk 0.1.0 → 0.1.1

package/dist/edit.d.ts

@@ -101,6 +101,7 @@ export declare class SizeSession extends EditSession<SizeSaveAnswer> {
         sceneHash: string;
         label?: string;
         check?: EditCheck;
+        elements?: EditElement[];
     }, edit: {
         name: string;
         input?: Record<string, unknown>;

package/dist/edit.js

@@ -1,11 +1,13 @@
 import { sessionHeader } from "./http.js";
 import { ReplayDivergedError, SessionGoneError, SizeChangedError } from "./errors.js";
+/** A check with nothing in it, for a session built before its first check. */
+const emptyCheck = () => ({ failures: [], warnings: [], objective: 0 });
 function answerOf(body) {
     return {
         elements: [],
         fixes: [],
         carried: {},
-        check: {},
+        check: emptyCheck(),
         refused: "",
         detail: "",
         limit: null,
@@ -228,8 +230,8 @@ export class SizeSession extends EditSession {
     static fromBatch(transport, r, edit) {
         const s = new SizeSession(transport, r.run, r.size, {
             id: r.session,
-            elements: [],
-            check: r.check ?? {},
+            elements: r.elements ?? [],
+            check: r.check ?? emptyCheck(),
             label: r.label || "loaded",
             sceneHash: r.sceneHash,
         });
@@ -307,9 +309,11 @@ async function openSizeRaw(t, runId, size) {
     const res = await t.send("POST", `/api/v1/jobs/${encodeURIComponent(runId)}/formats/${encodeURIComponent(size)}/edit`);
     const b = res.body;
     return {
+        run: (b.run ?? runId),
+        size: (b.size ?? size),
         id: b.session,
         elements: (b.elements ?? []),
-        check: (b.check ?? {}),
+        check: (b.check ?? emptyCheck()),
         label: (b.label ?? "loaded"),
         sceneHash: b.sceneHash,
         format: b.format,
@@ -321,7 +325,8 @@ async function openMasterRaw(t, masterId, version) {
 }
 /** Opens one size of a run for editing. */
 export async function openSize(t, runId, size) {
-    return new SizeSession(t, runId, size, await openSizeRaw(t, runId, size));
+    const o = await openSizeRaw(t, runId, size);
+    return new SizeSession(t, o.run, o.size, o);
 }
 /** Opens a master for editing: `version` is a number, or the latest by default. */
 export async function openMaster(t, masterId, o = {}) {
@@ -329,7 +334,7 @@ export async function openMaster(t, masterId, o = {}) {
     return new MasterSession(t, {
         id: b.session,
         elements: b.elements ?? [],
-        check: b.check ?? {},
+        check: b.check ?? emptyCheck(),
         label: b.label ?? "loaded",
         master: b.master,
         ifMatch: b.ifMatch,

package/dist/index.d.ts

@@ -49,6 +49,7 @@ export declare function createMestra(options: MestraOptions): {
         detail?: string;
         limit?: Record<string, never>;
         candidates?: import("./v1.js").components["schemas"]["EditCandidate"][];
+        elements?: import("./v1.js").components["schemas"]["EditElement"][];
     }>>;
     /** The raw first answer of a save across sizes. */
     startSaveSizes: (sessions: SizeSession[], idempotencyKey?: string) => Promise<SizesProgress<{
@@ -78,6 +79,7 @@ export declare function createMestra(options: MestraOptions): {
         detail?: string;
         limit?: Record<string, never>;
         candidates?: import("./v1.js").components["schemas"]["EditCandidate"][];
+        elements?: import("./v1.js").components["schemas"]["EditElement"][];
     } | {
         session: string;
         outcome: "saved" | "failed";
@@ -105,6 +107,7 @@ export declare function createMestra(options: MestraOptions): {
         detail?: string;
         limit?: Record<string, never>;
         candidates?: import("./v1.js").components["schemas"]["EditCandidate"][];
+        elements?: import("./v1.js").components["schemas"]["EditElement"][];
     } | {
         session: string;
         outcome: "saved" | "failed";

package/dist/sizes.js

@@ -10,6 +10,7 @@ function progressOf(status, body) {
     if (status === 202 || body.operation !== undefined) {
         return {
             operation: body.operation,
+            ...(body.kind ? { kind: body.kind } : {}),
             status: body.status,
             done: body.done,
             total: body.total,
@@ -63,10 +64,10 @@ export async function editSizes(t, req, o = {}) {
     const last = await finish(t, await startEditSizes(t, req), o);
     const results = last.results.map((r) => {
         if (r.session && r.sceneHash && r.run && r.size) {
-            const { session: id, sceneHash, run, size, label, check } = r;
+            const { session: id, sceneHash, run, size, label, check, elements } = r;
             return {
                 ...r,
-                editSession: SizeSession.fromBatch(t, { run, size, session: id, sceneHash, ...(label ? { label } : {}), ...(check ? { check } : {}) }, req.edit),
+                editSession: SizeSession.fromBatch(t, { run, size, session: id, sceneHash, ...(label ? { label } : {}), ...(check ? { check } : {}), ...(elements ? { elements } : {}) }, req.edit),
             };
         }
         return r;

package/dist/types.d.ts

@@ -97,6 +97,8 @@ export interface FormatInfo {
 /** The progress of a call across sizes. A call that finished at once is `done` with no `operation`. */
 export interface SizesProgress<R> {
     operation?: string;
+    /** Which call the operation is (`edit` or `save`); absent on a call that finished at once. */
+    kind?: "edit" | "save";
     status: "running" | "done";
     done: number;
     total: number;