@hraness/slopcamera 3.2.7 → 3.3.1

package/apps/desktop/application/operations/recording/shared.ts

@@ -1,199 +0,0 @@
-import { z } from "zod";
-
-import {
-  CapturePermissionsSchema,
-  IsoTimestampSchema,
-  MicrosecondsSchema,
-  RecordingIdSchema,
-} from "../../../contracts";
-import type {
-  ApplicationContext,
-  ApplicationRecordingController,
-} from "../../context";
-import { ApplicationError } from "../../errors";
-import type {
-  BoundedOperationSummary,
-  OperationExecutionContext,
-  OperationKind,
-  OperationPolicy,
-} from "../../operation";
-import { throwIfAborted } from "../shared";
-
-export const MAX_RECORDING_OPERATION_DISPLAYS = 16;
-
-const DisplayIdSchema = z.string().min(1).max(64);
-const DeviceIdSchema = z.string().min(1).max(256);
-
-const ExplicitDisplayIdsSchema = z.array(DisplayIdSchema)
-  .min(1)
-  .max(MAX_RECORDING_OPERATION_DISPLAYS)
-  .superRefine((displayIds, context) => {
-    if (new Set(displayIds).size !== displayIds.length) {
-      context.addIssue({
-        code: "custom",
-        message: "Explicit recording display IDs must be unique.",
-      });
-    }
-  });
-
-export const RecordingDisplaySelectionSchema = z.discriminatedUnion("kind", [
-  z.strictObject({
-    kind: z.literal("all"),
-  }),
-  z.strictObject({
-    displayIds: ExplicitDisplayIdsSchema,
-    kind: z.literal("selected"),
-  }),
-]);
-
-export const RecordingDeviceSelectionSchema = z.discriminatedUnion("kind", [
-  z.strictObject({ kind: z.literal("disabled") }),
-  z.strictObject({ kind: z.literal("default") }),
-  z.strictObject({ deviceId: DeviceIdSchema, kind: z.literal("device") }),
-]);
-
-const RecordingStartFields = {
-  camera: RecordingDeviceSelectionSchema,
-  displays: RecordingDisplaySelectionSchema,
-  microphone: RecordingDeviceSelectionSchema,
-  strictInputs: z.boolean(),
-  systemAudio: z.boolean(),
-  typedText: z.boolean(),
-} as const;
-
-export const RecordingStartInputSchema = z.strictObject(
-  RecordingStartFields,
-);
-
-export const EffectiveRecordingConfigSchema = z.strictObject({
-  ...RecordingStartFields,
-  metadata: z.literal(true),
-});
-
-const RecordingOperationOutputFields = {
-  completedSegmentCount: z.number().int().safe().nonnegative(),
-  effectiveConfig: EffectiveRecordingConfigSchema.nullable(),
-  logicalTimeUs: MicrosecondsSchema,
-  permissions: CapturePermissionsSchema.nullable(),
-  recordingId: RecordingIdSchema.nullable(),
-  state: z.enum(["idle", "recording", "paused"]),
-  updatedAt: IsoTimestampSchema.max(64),
-} as const;
-
-export const RecordingOperationOutputSchema = z.strictObject(
-  RecordingOperationOutputFields,
-);
-
-const ControllerRecordingSnapshotSchema = z.strictObject({
-  ...RecordingOperationOutputFields,
-  recordingRoot: z.string().min(1).max(4_096).nullable(),
-});
-
-export const EmptyRecordingOperationInputSchema = z.strictObject({});
-
-export type RecordingStartInput = z.infer<typeof RecordingStartInputSchema>;
-export type RecordingOperationOutput = z.infer<
-  typeof RecordingOperationOutputSchema
->;
-export type EmptyRecordingOperationInput = z.infer<
-  typeof EmptyRecordingOperationInputSchema
->;
-
-export const recordingStartPolicy = {
-  cache: "none",
-  cancellable: false,
-  effect: "live-control",
-  maxDurationMs: 5 * 60_000,
-  maxFanOut: 0,
-  maxInputBytes: 32 * 1_024,
-  maxOutputBytes: 64 * 1_024,
-  preparation: [
-    "recording-metadata",
-    "screen-capture",
-    "camera",
-    "microphone",
-    "system-audio",
-    "typed-text",
-    "window-metadata",
-  ],
-  resources: [{ amount: 1, resource: "capture-device" }],
-  resume: "non-resumable-live",
-} as const satisfies OperationPolicy;
-
-export const recordingTransitionPolicy = {
-  cache: "none",
-  cancellable: false,
-  effect: "live-control",
-  maxDurationMs: 5 * 60_000,
-  maxFanOut: 0,
-  maxInputBytes: 64,
-  maxOutputBytes: 64 * 1_024,
-  preparation: [],
-  resources: [{ amount: 1, resource: "capture-device" }],
-  resume: "non-resumable-live",
-} as const satisfies OperationPolicy;
-
-function requireRecordingController(
-  application: ApplicationContext,
-): ApplicationRecordingController {
-  const controller = application.recordingController;
-  if (controller === undefined) {
-    throw new ApplicationError(
-      "unavailable",
-      "Recording controller is unavailable.",
-    );
-  }
-  return controller;
-}
-
-export function parseRecordingOperationOutput(
-  value: unknown,
-): RecordingOperationOutput {
-  const parsed = ControllerRecordingSnapshotSchema.safeParse(value);
-  if (!parsed.success) {
-    throw new ApplicationError(
-      "invalid-data",
-      "Recording controller returned an invalid bounded snapshot.",
-    );
-  }
-  const snapshot = parsed.data;
-  return RecordingOperationOutputSchema.parse({
-    completedSegmentCount: snapshot.completedSegmentCount,
-    effectiveConfig: snapshot.effectiveConfig,
-    logicalTimeUs: snapshot.logicalTimeUs,
-    permissions: snapshot.permissions,
-    recordingId: snapshot.recordingId,
-    state: snapshot.state,
-    updatedAt: snapshot.updatedAt,
-  });
-}
-
-export async function executeRecordingControl(
-  context: OperationExecutionContext,
-  action: "pause" | "resume" | "start" | "stop",
-  options?: RecordingStartInput,
-): Promise<RecordingOperationOutput> {
-  throwIfAborted(context.abortSignal);
-  const controller = requireRecordingController(context.application);
-  await context.workflow?.beforePublication();
-  const snapshot = options === undefined
-    ? await controller.execute(action)
-    : await controller.execute(action, options);
-  return parseRecordingOperationOutput(snapshot);
-}
-
-export function summarizeRecordingControl(
-  kind: Extract<OperationKind, `recording.${string}`>,
-  output: RecordingOperationOutput,
-): BoundedOperationSummary {
-  return {
-    fields: {
-      completedSegmentCount: output.completedSegmentCount,
-      logicalTimeUs: output.logicalTimeUs,
-      recordingId: output.recordingId,
-      state: output.state,
-      updatedAt: output.updatedAt,
-    },
-    kind,
-  };
-}

package/apps/desktop/application/operations/recording/start.ts

@@ -1,169 +0,0 @@
-import { z } from "zod";
-
-import {
-  CapturePermissionsSchema,
-  IsoTimestampSchema,
-  MicrosecondsSchema,
-  RecordingIdSchema,
-} from "../../../contracts";
-import type { OperationDefinition } from "../../operation";
-import {
-  executeRecordingControl,
-  MAX_RECORDING_OPERATION_DISPLAYS,
-  RecordingOperationOutputSchema,
-  type RecordingOperationOutput,
-  RecordingStartInputSchema,
-  type RecordingStartInput,
-  recordingStartPolicy,
-  summarizeRecordingControl,
-} from "./shared";
-
-export const RecordingStartOutputSchema = RecordingOperationOutputSchema;
-export type RecordingStartOutput = RecordingOperationOutput;
-
-const RecordingDisplaySelectionV1Schema = z.discriminatedUnion("kind", [
-  z.strictObject({ kind: z.literal("all-current") }),
-  z.strictObject({
-    displayIds: z.array(z.string().min(1).max(256))
-      .min(1)
-      .max(MAX_RECORDING_OPERATION_DISPLAYS)
-      .superRefine((displayIds, context) => {
-        if (new Set(displayIds).size !== displayIds.length) {
-          context.addIssue({
-            code: "custom",
-            message: "Explicit recording display IDs must be unique.",
-          });
-        }
-      }),
-    kind: z.literal("explicit"),
-  }),
-]);
-
-export const RecordingStartInputV1Schema = z.strictObject({
-  displaySelection: RecordingDisplaySelectionV1Schema,
-  microphone: z.boolean(),
-  strictInputs: z.boolean(),
-  systemAudio: z.boolean(),
-  typedText: z.boolean(),
-  webcam: z.boolean(),
-});
-
-const EffectiveRecordingConfigV1Schema = z.strictObject({
-  ...RecordingStartInputV1Schema.shape,
-  metadata: z.literal(true),
-});
-
-export const RecordingStartOutputV1Schema = z.strictObject({
-  completedSegmentCount: z.number().int().safe().nonnegative(),
-  effectiveConfig: EffectiveRecordingConfigV1Schema.nullable(),
-  logicalTimeUs: MicrosecondsSchema,
-  permissions: CapturePermissionsSchema.nullable(),
-  recordingId: RecordingIdSchema.nullable(),
-  state: z.enum(["idle", "recording", "paused"]),
-  updatedAt: IsoTimestampSchema.max(64),
-});
-
-export type RecordingStartInputV1 = z.infer<
-  typeof RecordingStartInputV1Schema
->;
-export type RecordingStartOutputV1 = z.infer<
-  typeof RecordingStartOutputV1Schema
->;
-
-function upgradeRecordingStartInput(
-  input: RecordingStartInputV1,
-): RecordingStartInput {
-  return RecordingStartInputSchema.parse({
-    camera: { kind: input.webcam ? "default" : "disabled" },
-    displays: input.displaySelection.kind === "all-current"
-      ? { kind: "all" }
-      : {
-          displayIds: input.displaySelection.displayIds,
-          kind: "selected",
-        },
-    microphone: { kind: input.microphone ? "default" : "disabled" },
-    strictInputs: input.strictInputs,
-    systemAudio: input.systemAudio,
-    typedText: input.typedText,
-  });
-}
-
-function downgradeRecordingStartOutput(
-  output: RecordingStartOutput,
-): RecordingStartOutputV1 {
-  const effectiveConfig = output.effectiveConfig === null
-    ? null
-    : {
-        displaySelection: output.effectiveConfig.displays.kind === "all"
-          ? { kind: "all-current" as const }
-          : {
-              displayIds: output.effectiveConfig.displays.displayIds,
-              kind: "explicit" as const,
-            },
-        metadata: true as const,
-        microphone: output.effectiveConfig.microphone.kind !== "disabled",
-        strictInputs: output.effectiveConfig.strictInputs,
-        systemAudio: output.effectiveConfig.systemAudio,
-        typedText: output.effectiveConfig.typedText,
-        webcam: output.effectiveConfig.camera.kind !== "disabled",
-      };
-  return RecordingStartOutputV1Schema.parse({
-    ...output,
-    effectiveConfig,
-  });
-}
-
-export const recordingStartOperationDefinitionV1: OperationDefinition<
-  "recording.start",
-  RecordingStartInputV1,
-  RecordingStartOutputV1
-> = {
-  inputSchema: RecordingStartInputV1Schema,
-  inputSchemaId: "slopcamera.operation.recording.start.input/v1",
-  kind: "recording.start",
-  lifecycle: {
-    kind: "live-control",
-    execute: async (context, input) => downgradeRecordingStartOutput(
-      await executeRecordingControl(
-        context,
-        "start",
-        upgradeRecordingStartInput(input),
-      ),
-    ),
-  },
-  outputSchema: RecordingStartOutputV1Schema,
-  outputSchemaId: "slopcamera.operation.recording.start.output/v1",
-  policy: recordingStartPolicy,
-  summarize: output => ({
-    fields: {
-      completedSegmentCount: output.completedSegmentCount,
-      logicalTimeUs: output.logicalTimeUs,
-      recordingId: output.recordingId,
-      state: output.state,
-      updatedAt: output.updatedAt,
-    },
-    kind: "recording.start",
-  }),
-  version: 1,
-};
-
-export const recordingStartOperationDefinition: OperationDefinition<
-  "recording.start",
-  RecordingStartInput,
-  RecordingStartOutput
-> = {
-  inputSchema: RecordingStartInputSchema,
-  inputSchemaId: "slopcamera.operation.recording.start.input/v2",
-  kind: "recording.start",
-  lifecycle: {
-    kind: "live-control",
-    execute: async (context, input) => (
-      await executeRecordingControl(context, "start", input)
-    ),
-  },
-  outputSchema: RecordingStartOutputSchema,
-  outputSchemaId: "slopcamera.operation.recording.start.output/v2",
-  policy: recordingStartPolicy,
-  summarize: output => summarizeRecordingControl("recording.start", output),
-  version: 2,
-};

package/apps/desktop/application/operations/recording/stop.ts

@@ -1,34 +0,0 @@
-import type { OperationDefinition } from "../../operation";
-import {
-  EmptyRecordingOperationInputSchema,
-  type EmptyRecordingOperationInput,
-  executeRecordingControl,
-  RecordingOperationOutputSchema,
-  type RecordingOperationOutput,
-  recordingTransitionPolicy,
-  summarizeRecordingControl,
-} from "./shared";
-
-export const RecordingStopInputSchema = EmptyRecordingOperationInputSchema;
-export const RecordingStopOutputSchema = RecordingOperationOutputSchema;
-export type RecordingStopInput = EmptyRecordingOperationInput;
-export type RecordingStopOutput = RecordingOperationOutput;
-
-export const recordingStopOperationDefinition: OperationDefinition<
-  "recording.stop",
-  RecordingStopInput,
-  RecordingStopOutput
-> = {
-  inputSchema: RecordingStopInputSchema,
-  inputSchemaId: "slopcamera.operation.recording.stop.input/v1",
-  kind: "recording.stop",
-  lifecycle: {
-    kind: "live-control",
-    execute: async context => await executeRecordingControl(context, "stop"),
-  },
-  outputSchema: RecordingStopOutputSchema,
-  outputSchemaId: "slopcamera.operation.recording.stop.output/v1",
-  policy: recordingTransitionPolicy,
-  summarize: output => summarizeRecordingControl("recording.stop", output),
-  version: 1,
-};