@shop-os/modelkit 0.4.3 → 0.4.5

package/dist/index.cjs

@@ -2617,16 +2617,26 @@ var ArraysSchema = import_zod2.z.record(import_zod2.z.string().min(1), import_zo
     }
   }
 });
+var DimensionsSchema = import_zod2.z.strictObject({
+  field: import_zod2.z.string().min(1),
+  areas: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.number().int().positive()).refine((a) => Object.keys(a).length > 0, {
+    message: "inputSpec.dimensions.areas must name at least one size"
+  }),
+  maxSide: import_zod2.z.number().int().positive().optional(),
+  multipleOf: import_zod2.z.number().int().positive().optional()
+});
 var InputSpecSchema = import_zod2.z.strictObject({
   fields: FieldsSchema,
   values: ValuesSchema.optional(),
   static: StaticSchema.optional(),
   arrays: ArraysSchema.optional(),
-  editEndpoint: import_zod2.z.string().min(1).optional()
+  editEndpoint: import_zod2.z.string().min(1).optional(),
+  dimensions: DimensionsSchema.optional()
 }).superRefine((spec, ctx) => {
   const mappedNames = /* @__PURE__ */ new Set([
     ...Object.values(spec.fields),
-    ...Object.keys(spec.arrays ?? {})
+    ...Object.keys(spec.arrays ?? {}),
+    ...spec.dimensions ? [spec.dimensions.field] : []
   ]);
   for (const key of Object.keys(spec.static ?? {})) {
     if (mappedNames.has(key)) {
@@ -2661,7 +2671,10 @@ function validateInputSpec(raw, row) {
     return {
       ok: false,
       issues: [
-        { path: [], message: "inputSpec is only supported on replicate and fal rows" }
+        {
+          path: [],
+          message: "inputSpec is only supported on replicate and fal rows"
+        }
       ]
     };
   }
@@ -2754,6 +2767,29 @@ function validateInputSpec(raw, row) {
       }
     }
   }
+  if (spec.dimensions !== void 0) {
+    if (row.type !== "image") {
+      issues.push({
+        path: ["dimensions"],
+        message: "inputSpec.dimensions is only supported on image rows"
+      });
+    }
+    for (const key of ["aspectRatio", "size"]) {
+      if (key in spec.fields) {
+        issues.push({
+          path: ["fields", key],
+          message: `inputSpec.fields "${key}" cannot be set with inputSpec.dimensions, which sends it`
+        });
+      }
+    }
+    const owner = seenNames.get(spec.dimensions.field);
+    if (owner !== void 0 || spec.dimensions.field in (spec.arrays ?? {})) {
+      issues.push({
+        path: ["dimensions", "field"],
+        message: `inputSpec.dimensions.field "${spec.dimensions.field}" is already a mapped provider field`
+      });
+    }
+  }
   const supports = row.constraints.supports ?? [];
   for (const key of INPUT_SPEC_SUPPORTS_KEYS) {
     if (supports.includes(key)) continue;
@@ -4215,6 +4251,20 @@ var import_zod11 = require("zod");
 
 // src/catalog/video-tools-spec.ts
 var import_zod10 = require("zod");
+
+// src/video-length.ts
+function tenths(seconds2) {
+  return Math.round(seconds2 * 10) / 10;
+}
+function overMax(seconds2, max) {
+  return seconds2 > max && tenths(seconds2) > max;
+}
+function overTotal(lengths, total) {
+  const sum = (values) => values.reduce((acc, len) => acc + len, 0);
+  return sum(lengths) > total && tenths(sum(lengths.map(tenths))) > total;
+}
+
+// src/catalog/video-tools-spec.ts
 var RangeSchema2 = import_zod10.z.object({ min: import_zod10.z.number(), max: import_zod10.z.number() });
 var ToolSchema = import_zod10.z.object({
   kind: import_zod10.z.enum(["upscale", "interpolate", "hdr"]),
@@ -4258,7 +4308,7 @@ function planVideoTool(row, req) {
     return fail("The source video's width, height and duration are required");
   }
   const maxSeconds = row.constraints.sourceVideoSeconds?.max;
-  if (maxSeconds !== void 0 && durationSeconds > maxSeconds) {
+  if (maxSeconds !== void 0 && overMax(durationSeconds, maxSeconds)) {
     return fail(`${row.label} takes source videos up to ${maxSeconds} seconds.`);
   }
   const base = {
@@ -4570,11 +4620,37 @@ function applyInputSpec(spec, req, refToUrl2, opts) {
     }
     if (urls.length > 0) out[providerField] = urls;
   }
+  if (spec.dimensions !== void 0) {
+    const dims = dimensionsFor(spec.dimensions, req);
+    if (dims !== void 0) out[spec.dimensions.field] = dims;
+  }
   for (const [key, value] of Object.entries(spec.static ?? {})) {
     out[key] = value;
   }
   return out;
 }
+function dimensionsFor(dims, req) {
+  const ratio = req.aspectRatio;
+  const size = req.size;
+  if (ratio === void 0 || ratio === "adaptive" || size === void 0) return void 0;
+  const area = dims.areas[size];
+  const match = /^(\d+):(\d+)$/.exec(ratio);
+  if (area === void 0 || match === null) return void 0;
+  const r = Number(match[1]) / Number(match[2]);
+  let width = Math.sqrt(area * r);
+  let height = width / r;
+  const longest = Math.max(width, height);
+  if (dims.maxSide !== void 0 && longest > dims.maxSide) {
+    const scale = dims.maxSide / longest;
+    width *= scale;
+    height *= scale;
+  }
+  const step = dims.multipleOf ?? 1;
+  return {
+    width: Math.max(step, Math.floor(width / step) * step),
+    height: Math.max(step, Math.floor(height / step) * step)
+  };
+}
 function resolveRowInputSpec(req, ctx) {
   const raw = ctx.model.providerOptions?.["modelkit"]?.["inputSpec"];
   if (raw === void 0) return { kind: "absent" };
@@ -8634,7 +8710,7 @@ function videoLengthViolation(model, input) {
   const lengths = (input.referenceVideos ?? []).map(knownLength);
   if (limits?.max !== void 0) {
     const max = limits.max;
-    const i = lengths.findIndex((len) => len !== void 0 && len > max);
+    const i = lengths.findIndex((len) => len !== void 0 && overMax(len, max));
     if (i >= 0)
       return `${model.label} takes reference videos up to ${String(max)} s each; video ${i + 1} is ${seconds(lengths[i], max)} s.`;
   }
@@ -8646,14 +8722,17 @@ function videoLengthViolation(model, input) {
   const source = knownLength(input.sourceVideo);
   const sourceLimits = model.constraints.sourceVideoSeconds;
   if (limits?.total !== void 0) {
-    const refSum = lengths.reduce((acc, len) => acc + (len ?? 0), 0);
-    const sum = refSum + (sourceLimits?.inReferenceTotal ? source ?? 0 : 0);
-    if (sum > limits.total)
+    const counted = [
+      ...lengths.filter((len) => len !== void 0),
+      ...sourceLimits?.inReferenceTotal && source !== void 0 ? [source] : []
+    ];
+    const sum = counted.reduce((acc, len) => acc + len, 0);
+    if (overTotal(counted, limits.total))
       return `${model.label} takes reference videos up to ${String(limits.total)} s combined; these add up to ${seconds(sum, limits.total)} s.`;
   }
   if (source === void 0) return void 0;
   const sourceMin = effectiveMin(sourceLimits, input.taskType);
-  if (sourceLimits?.max !== void 0 && source > sourceLimits.max)
+  if (sourceLimits?.max !== void 0 && overMax(source, sourceLimits.max))
     return `${model.label} takes a source video up to ${String(sourceLimits.max)} s; this one is ${seconds(source, sourceLimits.max)} s.`;
   if (sourceMin !== void 0 && source < sourceMin)
     return `${model.label} takes a source video of at least ${String(sourceMin)} s; this one is ${seconds(source, sourceMin)} s.`;