@vivix-labs/project-studio 0.0.0-stage → 1.0.0-beta

package/dist/client.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { StudioConfig } from './shared.js';
+export { studioConfig as Config } from './shared.js';
+import { ClientContext } from 'vivix-studio/sdk/client';
+import 'vivix-studio/sdk/shared';
+import './shared-BUdviVVD.js';
+
+declare function AssetPreview({ location, kind }: {
+    location: any;
+    kind: string;
+}): React.JSX.Element;
+declare function AssetProperties({ record }: {
+    record: any;
+}): React.JSX.Element;
+
+declare const dependencies: (config: StudioConfig) => string[];
+declare function activate(client: ClientContext<StudioConfig>): void;
+
+export { AssetPreview, AssetProperties, activate as default, dependencies };

package/dist/client.js

@@ -0,0 +1,3 @@
+import './client.css';
+export * from './client.bundle.js';
+export { default } from './client.bundle.js';

package/dist/events.d.ts

@@ -0,0 +1,102 @@
+import { R as RecordValue, J as JSONValue, S as Scope } from './shared-BUdviVVD.js';
+import { z, EventDefinition, Events } from 'vivix-studio/sdk/shared';
+
+declare const taskEventNames: readonly ["project-studio/task.completed", "project-studio/task.failed", "project-studio/task.cancelled", "project-studio/billing.updated"];
+declare const taskNotice: z.ZodObject<{
+    taskId: z.ZodString;
+    attemptId: z.ZodString;
+    revision: z.ZodNumber;
+    requestedCount: z.ZodNullable<z.ZodNumber>;
+    resultCount: z.ZodNullable<z.ZodNumber>;
+    partialResults: z.ZodNullable<z.ZodBoolean>;
+    results: z.ZodArray<z.ZodObject<{
+        remoteTaskId: z.ZodString;
+        outputIndex: z.ZodNumber;
+        assetId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const billingNotice: z.ZodObject<{
+    taskId: z.ZodString;
+    attemptId: z.ZodString;
+    billingRecordId: z.ZodString;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+declare const eventDefinitions: readonly EventDefinition[];
+type RemoteOutcome = 'succeeded' | 'failed' | 'cancelled' | 'unknown';
+interface TaskStateProjection {
+    format: 1;
+    remote: {
+        status: RemoteOutcome;
+        revision: number;
+        requestedCount: number | null;
+        resultCount: number | null;
+        partialResults: boolean | null;
+        resultSignature?: string;
+    };
+    billing?: {
+        billingRecordId: string;
+        revision: number;
+        semanticDigest: string;
+    };
+}
+interface BillingView {
+    billingRecordId: string;
+    taskId: string;
+    attemptId: string;
+    revision: number;
+    status: 'pending' | 'settled' | 'released' | 'unavailable';
+    amount: {
+        value: string;
+        unit: string;
+    } | null;
+}
+declare function readableResults(record: RecordValue): {
+    remoteTaskId: string;
+    outputIndex: number;
+}[];
+declare function taskState(record: RecordValue): TaskStateProjection;
+declare function stateMetadata(before: RecordValue, data: any, observation?: {
+    status?: string;
+    resultCount: number | null;
+}): Record<string, JSONValue>;
+declare function taskProjection(record: RecordValue): {
+    projection: {
+        attemptId: string;
+        remoteOutcome: {
+            status: RemoteOutcome;
+            revision: number;
+            requestedCount: number | null;
+            resultCount: number | null;
+            partialResults: boolean | null;
+            resultSignature?: string;
+        };
+        localPersistence: string;
+        billing: BillingView;
+    };
+    storeId: string;
+    scope: Scope;
+    objectId: string;
+    typeId: string;
+    schemaVersion: number;
+    revision: number;
+    data: any;
+    metadata: Record<string, JSONValue>;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+};
+/** I4 integration seam. It accepts only the I4 contract, never estimates or task state. */
+declare function billingViewFromI4(record: RecordValue, cost: {
+    status: string;
+    credits: string | null;
+}, revision: number): BillingView;
+declare function taskBillingView(record: RecordValue): BillingView;
+/** Integrates accepted fees without replacing the remote semantic projection. */
+declare function billingMetadata(before: RecordValue, cost: {
+    status: string;
+    credits: string | null;
+}): Record<string, JSONValue>;
+/** Call only after the synchronous business transaction has committed. */
+declare function notifyCommitted(events: () => Events, before: RecordValue, after: RecordValue, diagnostic?: (code: string) => void): void;
+
+export { type BillingView, type RemoteOutcome, type TaskStateProjection, billingMetadata, billingNotice, billingViewFromI4, eventDefinitions, notifyCommitted, readableResults, stateMetadata, taskBillingView, taskEventNames, taskNotice, taskProjection, taskState };

package/dist/events.js

@@ -0,0 +1,244 @@
+// packages/project-studio/src/events.ts
+import { z as z2 } from "vivix-studio/sdk/shared";
+
+// packages/vivix-api/src/billing.ts
+import { z } from "vivix-studio/sdk/shared";
+var taskBilling = z.object({
+  status: z.enum(["pending", "settled", "released", "unavailable"]),
+  credits: z.string().regex(/^\d+(?:\.\d+)?$/).nullable()
+}).strict().refine(
+  (value) => value.status === "settled" ? value.credits !== null : value.status === "released" ? value.credits === "0" : value.credits === null
+);
+function readTaskBilling(response) {
+  const parsed = taskBilling.safeParse(response?.billing);
+  return parsed.success ? parsed.data : { status: "unavailable", credits: null };
+}
+
+// packages/project-studio/src/events.ts
+var taskEventNames = [
+  "project-studio/task.completed",
+  "project-studio/task.failed",
+  "project-studio/task.cancelled",
+  "project-studio/billing.updated"
+];
+var result = z2.object({
+  remoteTaskId: z2.string(),
+  outputIndex: z2.number().int().nonnegative(),
+  assetId: z2.string().optional()
+}).strict();
+var taskNotice = z2.object({
+  taskId: z2.string(),
+  attemptId: z2.string(),
+  revision: z2.number().int().positive(),
+  requestedCount: z2.number().int().positive().nullable(),
+  resultCount: z2.number().int().nonnegative().nullable(),
+  partialResults: z2.boolean().nullable(),
+  results: z2.array(result)
+}).strict();
+var billingNotice = z2.object({
+  taskId: z2.string(),
+  attemptId: z2.string(),
+  billingRecordId: z2.string(),
+  revision: z2.number().int().positive()
+}).strict();
+var eventDefinitions = taskEventNames.map((name) => ({
+  name,
+  version: 1,
+  mode: "notification",
+  schema: name.endsWith("billing.updated") ? "schemas/billing-notice.json" : "schemas/task-notice.json",
+  scope: "project"
+}));
+var stateKey = "project-studio.state";
+function saved(record) {
+  const value = record.metadata?.[stateKey];
+  return value?.format === 1 && value.remote && Number.isSafeInteger(value.remote.revision) ? value : void 0;
+}
+function readableResults(record) {
+  if (typeof record.data.remoteTaskId !== "string" || !record.data.remoteTaskId) return [];
+  return (record.data.remoteOutputs || []).flatMap((value, outputIndex) => {
+    if (!value || typeof value !== "object") return [];
+    const output = value;
+    return ["asset_id", "file_id", "id", "url", "download_url", "content", "text"].some(
+      (k) => typeof output[k] === "string" && Boolean(output[k])
+    ) ? [{ remoteTaskId: record.data.remoteTaskId, outputIndex }] : [];
+  });
+}
+function outcome(record) {
+  const d = record.data;
+  if (d.remoteStatus === "succeeded" && readableResults(record).length) return "succeeded";
+  if (d.remoteStatus === "failed") return "failed";
+  if (["cancelled", "canceled"].includes(d.remoteStatus) || d.state === "canceled" && !d.submittedAt && !d.remoteTaskId && d.attemptCount === 0)
+    return "cancelled";
+  return "unknown";
+}
+function taskState(record) {
+  const old = saved(record), status = outcome(record);
+  const requestedCount = Number.isInteger(record.data.inputSnapshot?.outputCount) ? record.data.inputSnapshot.outputCount : null;
+  const resultSignature = JSON.stringify(readableResults(record));
+  const storedCount = Array.isArray(record.data.remoteOutputs) ? record.data.remoteOutputs.length : null;
+  const unchanged = old?.remote.status === status && old.remote.requestedCount === requestedCount && old.remote.resultSignature === resultSignature && (old.remote.resultCount === null || old.remote.resultCount === storedCount);
+  const resultCount = status === "unknown" ? null : unchanged ? old.remote.resultCount : record.data.remoteOutputs?.length ? record.data.remoteOutputs.length : null;
+  return {
+    format: 1,
+    remote: {
+      status,
+      revision: unchanged ? old.remote.revision : record.revision,
+      requestedCount,
+      resultCount,
+      partialResults: requestedCount !== null && resultCount !== null ? resultCount < requestedCount : null,
+      resultSignature
+    },
+    billing: currentBilling(record, old?.billing)
+  };
+}
+function stateMetadata(before, data, observation) {
+  const previous = taskState(before), next = taskState({ ...before, data, metadata: {} });
+  if (observation && next.remote.status !== "unknown")
+    next.remote.resultCount = observation.resultCount;
+  else if (previous.remote.status === next.remote.status)
+    next.remote.resultCount = previous.remote.resultCount;
+  next.remote.partialResults = next.remote.requestedCount !== null && next.remote.resultCount !== null ? next.remote.resultCount < next.remote.requestedCount : null;
+  const signature = ({ revision: _, ...r }) => JSON.stringify(r);
+  next.remote.revision = signature(next.remote) === signature(previous.remote) ? previous.remote.revision : before.revision + 1;
+  const view = billingViewFromI4(
+    before,
+    data.cost ?? { status: "unavailable", credits: null },
+    before.revision + 1
+  );
+  const semanticDigest = billingDigest(view);
+  next.billing = {
+    billingRecordId: view.billingRecordId,
+    semanticDigest,
+    revision: previous.billing?.semanticDigest === semanticDigest ? previous.billing.revision : before.revision + 1
+  };
+  return { ...before.metadata, [stateKey]: next };
+}
+function taskProjection(record) {
+  const s = taskState(record), d = record.data;
+  const localPersistence = d.state === "succeeded" ? "saved" : d.state === "partial" ? "partial" : d.state === "save_failed" ? "failed" : d.state === "saving" && d.outputRefs?.length ? "partial" : "pending";
+  return {
+    ...record,
+    projection: {
+      attemptId: record.objectId,
+      remoteOutcome: s.remote,
+      localPersistence,
+      billing: taskBillingView(record)
+    }
+  };
+}
+function billingViewFromI4(record, cost, revision) {
+  const { status, credits } = readTaskBilling({
+    billing: { status: cost.status, credits: cost.credits }
+  });
+  return {
+    billingRecordId: JSON.stringify([
+      record.storeId,
+      record.scope?.id,
+      record.objectId,
+      "task.cost"
+    ]),
+    taskId: record.objectId,
+    attemptId: record.objectId,
+    revision,
+    status,
+    amount: status === "settled" || status === "released" ? { value: credits.replace(/^0+(?=\d)/, ""), unit: "credits" } : null
+  };
+}
+function normalizeDecimal(value) {
+  const [whole, fraction = ""] = value.split(".");
+  const trimmed = fraction.replace(/0+$/, "");
+  return whole.replace(/^0+(?=\d)/, "") + (trimmed ? "." + trimmed : "");
+}
+function billingDigest(view) {
+  return JSON.stringify([
+    view.status,
+    view.amount && { ...view.amount, value: normalizeDecimal(view.amount.value) }
+  ]);
+}
+function currentBilling(record, old) {
+  const view = billingViewFromI4(
+    record,
+    record.data.cost ?? { status: "unavailable", credits: null },
+    record.revision
+  );
+  const semanticDigest = billingDigest(view);
+  return {
+    billingRecordId: view.billingRecordId,
+    semanticDigest,
+    revision: old?.semanticDigest === semanticDigest ? old.revision : record.revision
+  };
+}
+function taskBillingView(record) {
+  const state = taskState(record);
+  return billingViewFromI4(
+    record,
+    record.data.cost ?? { status: "unavailable", credits: null },
+    state.billing?.revision ?? record.revision
+  );
+}
+function billingMetadata(before, cost) {
+  const state = taskState(before), view = billingViewFromI4(before, cost, before.revision + 1), semanticDigest = billingDigest(view);
+  state.billing = {
+    billingRecordId: view.billingRecordId,
+    semanticDigest,
+    revision: state.billing?.semanticDigest === semanticDigest ? state.billing.revision : before.revision + 1
+  };
+  return { ...before.metadata, [stateKey]: state };
+}
+function notifyCommitted(events, before, after, diagnostic = (code) => console.error(code)) {
+  void (async () => {
+    const old = structuredClone(before), committed = structuredClone(after);
+    const a = taskState(old), b = taskState(committed), scope = events();
+    if (b.remote.status !== "unknown" && (a.remote.status !== b.remote.status || a.remote.revision !== b.remote.revision)) {
+      const name = b.remote.status === "succeeded" ? taskEventNames[0] : b.remote.status === "failed" ? taskEventNames[1] : taskEventNames[2];
+      const results = readableResults(committed);
+      await scope.emit(name, {
+        version: 1,
+        occurredAt: committed.updatedAt,
+        correlation: { taskId: committed.objectId, attemptId: committed.objectId },
+        entity: { type: "task", id: committed.objectId, revision: b.remote.revision },
+        payload: {
+          taskId: committed.objectId,
+          attemptId: committed.objectId,
+          revision: b.remote.revision,
+          requestedCount: b.remote.requestedCount,
+          resultCount: b.remote.resultCount,
+          partialResults: b.remote.partialResults,
+          results
+        }
+      });
+    }
+    if (b.billing && b.billing.revision !== a.billing?.revision)
+      await scope.emit(taskEventNames[3], {
+        version: 1,
+        occurredAt: committed.updatedAt,
+        correlation: { taskId: committed.objectId, attemptId: committed.objectId },
+        entity: { type: "billing", id: b.billing.billingRecordId, revision: b.billing.revision },
+        payload: {
+          taskId: committed.objectId,
+          attemptId: committed.objectId,
+          billingRecordId: b.billing.billingRecordId,
+          revision: b.billing.revision
+        }
+      });
+  })().catch(() => {
+    try {
+      diagnostic("EVENT_NOTIFICATION_FAILED");
+    } catch {
+    }
+  });
+}
+export {
+  billingMetadata,
+  billingNotice,
+  billingViewFromI4,
+  eventDefinitions,
+  notifyCommitted,
+  readableResults,
+  stateMetadata,
+  taskBillingView,
+  taskEventNames,
+  taskNotice,
+  taskProjection,
+  taskState
+};

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'vivix-studio/sdk/shared';
+import { ServerContext } from 'vivix-studio/sdk/server';
+
+declare const Config: z.ZodObject<{
+    role: z.ZodDefault<z.ZodEnum<{
+        project: "project";
+        coordinator: "coordinator";
+    }>>;
+    dataInstance: z.ZodDefault<z.ZodString>;
+    apiInstance: z.ZodDefault<z.ZodString>;
+    libraryInstance: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+declare const dependencies: (c: z.infer<typeof Config>) => string[];
+declare function activate(ctx: ServerContext<z.infer<typeof Config>>): Promise<void>;
+
+export { Config, activate as default, dependencies };