deepline 0.1.0 → 0.1.1

package/dist/repo/shared_libs/play-runtime/worker-api-types.ts

@@ -0,0 +1,140 @@
+export type PlayStagedFileRef = {
+  storageKind: 'r2';
+  storageKey: string;
+  logicalPath: string;
+  fileName: string;
+  contentHash: string;
+  contentType: string;
+  bytes: number;
+};
+
+export type PlayVisualNodeProgress = {
+  completed?: number;
+  total?: number;
+  failed?: number;
+  message?: string;
+  updatedAt?: number;
+  startedAt?: number;
+  completedAt?: number;
+  artifactTableNamespace?: string | null;
+};
+
+export type PlayVisualNodeProgressMap = Record<string, PlayVisualNodeProgress>;
+
+export type ComputeBillingItem = {
+  itemId: string;
+  source: string;
+  unit: string;
+  units: number;
+  providerCostUsd: number;
+  metadata?: unknown;
+};
+
+const DAYTONA_COMPUTE_PRICING_USD = {
+  vcpuSecond: 0.000014,
+  memoryGiBSecond: 0.0000045,
+  storageGiBSecond: 0.00000003,
+  includedStorageGiB: 5,
+} as const;
+
+const TEMPORAL_COMPUTE_PRICING_USD = {
+  action: 50 / 1_000_000,
+} as const;
+
+const NEON_COMPUTE_PRICING_USD = {
+  cuHour: 0.106,
+  defaultCu: 1,
+} as const;
+
+function roundUsd(amount: number): number {
+  return Number(Math.max(0, amount).toFixed(12));
+}
+
+export function resolveDaytonaSandboxComputeItem(input: {
+  itemId: string;
+  source?: string;
+  wallTimeSeconds: number;
+  cpu: number;
+  memoryGiB: number;
+  diskGiB: number;
+  sandboxId?: string | null;
+  startedAt?: number;
+  endedAt?: number;
+}): ComputeBillingItem {
+  const billableSeconds = Math.max(1, Math.ceil(input.wallTimeSeconds));
+  const cpu = Math.max(0, input.cpu);
+  const memoryGiB = Math.max(0, input.memoryGiB);
+  const billableDiskGiB = Math.max(
+    0,
+    input.diskGiB - DAYTONA_COMPUTE_PRICING_USD.includedStorageGiB,
+  );
+  const providerCostUsd = roundUsd(
+    billableSeconds *
+      (cpu * DAYTONA_COMPUTE_PRICING_USD.vcpuSecond +
+        memoryGiB * DAYTONA_COMPUTE_PRICING_USD.memoryGiBSecond +
+        billableDiskGiB *
+          DAYTONA_COMPUTE_PRICING_USD.storageGiBSecond),
+  );
+
+  return {
+    itemId: input.itemId,
+    source: input.source ?? 'daytona',
+    unit: 'sandbox_second',
+    units: billableSeconds,
+    providerCostUsd,
+    metadata: {
+      sandboxId: input.sandboxId ?? null,
+      cpu,
+      memoryGiB,
+      diskGiB: Math.max(0, input.diskGiB),
+      billableDiskGiB,
+      startedAt: input.startedAt,
+      endedAt: input.endedAt,
+    },
+  };
+}
+
+export function resolveTemporalComputeItem(input: {
+  itemId: string;
+  actions: number;
+  metadata?: unknown;
+}): ComputeBillingItem {
+  const actions = Math.max(0, Math.ceil(input.actions));
+  return {
+    itemId: input.itemId,
+    source: 'temporal',
+    unit: 'action',
+    units: actions,
+    providerCostUsd: roundUsd(actions * TEMPORAL_COMPUTE_PRICING_USD.action),
+    metadata: input.metadata,
+  };
+}
+
+export function resolveNeonComputeItem(input: {
+  itemId: string;
+  activeSeconds: number;
+  cu?: number;
+  metadata?: unknown;
+}): ComputeBillingItem {
+  const billableSeconds = Math.max(0, Math.ceil(input.activeSeconds));
+  const cu = Math.max(0, input.cu ?? NEON_COMPUTE_PRICING_USD.defaultCu);
+  return {
+    itemId: input.itemId,
+    source: 'neon',
+    unit: 'cu_second',
+    units: billableSeconds * cu,
+    providerCostUsd: roundUsd(
+      billableSeconds * cu * (NEON_COMPUTE_PRICING_USD.cuHour / 3600),
+    ),
+    metadata: {
+      activeSeconds: billableSeconds,
+      cu,
+      cuHourUsd: NEON_COMPUTE_PRICING_USD.cuHour,
+      ...(input.metadata && typeof input.metadata === 'object'
+        ? (input.metadata as Record<string, unknown>)
+        : input.metadata !== undefined
+          ? { inputMetadata: input.metadata }
+          : {}),
+    },
+  };
+}

package/dist/repo/shared_libs/plays/artifact-transport.ts

@@ -0,0 +1,14 @@
+import type { PlayBundleArtifact } from './artifact-types';
+
+const INLINE_SOURCE_MAP_PATTERN =
+  /\r?\n?\/\/# sourceMappingURL=data:application\/json;base64,[A-Za-z0-9+/=]+\s*$/;
+
+export function compactPlayArtifactForRuntimeTransport(
+  artifact: PlayBundleArtifact,
+): PlayBundleArtifact {
+  return {
+    ...artifact,
+    bundledCode: artifact.bundledCode.replace(INLINE_SOURCE_MAP_PATTERN, ''),
+    sourceMap: '',
+  };
+}

package/dist/repo/shared_libs/plays/artifact-types.ts

@@ -0,0 +1,49 @@
+export type PlayPackageImport = {
+  name: string;
+  version: string | null;
+};
+
+export type PlayImportPolicy = {
+  localFiles: string[];
+  nodeBuiltins: string[];
+  packages: PlayPackageImport[];
+};
+
+export type PlayRuntimeFeature =
+  | 'artifact_storage'
+  | 'checkpoint_resume'
+  | 'durable_sleep'
+  | 'packaged_files';
+
+export type PlayArtifactCompatibility = {
+  apiVersion: number;
+  artifactVersion: number;
+  minRunnerVersion: number;
+  runtimeFeatures: PlayRuntimeFeature[];
+  runtimeBackend?: string | null;
+};
+
+/**
+ * Identifies which runtime can consume this artifact:
+ *   - cjs_node20: Daytona / local-process (Node.js)
+ *   - esm_workers: Cloudflare Workers (V8 isolate)
+ */
+export type PlayArtifactKind = 'cjs_node20' | 'esm_workers';
+
+export type PlayBundleArtifact = {
+  codeFormat: 'cjs_module' | 'esm_module';
+  /** Defaults to cjs_node20 when not present (legacy artifacts). */
+  artifactKind?: PlayArtifactKind;
+  entryFile: string;
+  virtualFilename: string;
+  sourceHash: string;
+  graphHash: string;
+  artifactHash: string;
+  sourceMapHash: string;
+  bundledCode: string;
+  sourceMap: string;
+  importPolicy: PlayImportPolicy;
+  compatibility: PlayArtifactCompatibility;
+  generatedAt: number;
+  cacheHit: boolean;
+};