@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/src/slack-task-policy.ts

@@ -1,38 +1,48 @@
+import * as primitives from "./primitives";
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 
 export const SLACK_TASK_POLICY_ID_MAX_CHARS = 128;
 export const SLACK_TASK_POLICY_REASON_MAX_CHARS = 4_096;
 export const SLACK_TASK_POLICY_MAX_IDS = 256;
 
-const SlackOpaqueId = z.string().min(1).max(SLACK_TASK_POLICY_ID_MAX_CHARS);
+const SlackOpaqueId = /* @__PURE__ */ defineSchema(() =>
+  primitives.nonEmptyString.max(SLACK_TASK_POLICY_ID_MAX_CHARS),
+);
 
-export const SlackSharedConversationMode = z.enum(["deny", "private_handoff"]);
+export const SlackSharedConversationMode = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["deny", "private_handoff"]),
+);
 export type SlackSharedConversationMode = z.infer<typeof SlackSharedConversationMode>;
 
-export const SlackResultPublicationMode = z.enum(["never", "approval_required", "allow"]);
+export const SlackResultPublicationMode = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["never", "approval_required", "allow"]),
+);
 export type SlackResultPublicationMode = z.infer<typeof SlackResultPublicationMode>;
 
 function uniqueSortedIds(values: string[]): string[] {
   return [...new Set(values)].sort();
 }
 
-export const SlackTaskPolicyContent = z
-  .object({
-    allowedTeamIds: z
-      .array(SlackOpaqueId)
-      .max(SLACK_TASK_POLICY_MAX_IDS)
-      .transform(uniqueSortedIds),
-    allowedConversationIds: z
-      .array(SlackOpaqueId)
-      .max(SLACK_TASK_POLICY_MAX_IDS)
-      .transform(uniqueSortedIds),
-    allowGuestInitiators: z.boolean(),
-    allowExternalInitiators: z.boolean(),
-    allowMpim: z.boolean(),
-    sharedConversationMode: SlackSharedConversationMode,
-    resultPublicationMode: SlackResultPublicationMode,
-  })
-  .strict();
+export const SlackTaskPolicyContent = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      allowedTeamIds: z
+        .array(SlackOpaqueId)
+        .max(SLACK_TASK_POLICY_MAX_IDS)
+        .transform(uniqueSortedIds),
+      allowedConversationIds: z
+        .array(SlackOpaqueId)
+        .max(SLACK_TASK_POLICY_MAX_IDS)
+        .transform(uniqueSortedIds),
+      allowGuestInitiators: primitives.boolean,
+      allowExternalInitiators: primitives.boolean,
+      allowMpim: primitives.boolean,
+      sharedConversationMode: SlackSharedConversationMode,
+      resultPublicationMode: SlackResultPublicationMode,
+    })
+    .strict(),
+);
 export type SlackTaskPolicyContent = z.infer<typeof SlackTaskPolicyContent>;
 
 export const DEFAULT_SLACK_TASK_POLICY: SlackTaskPolicyContent = Object.freeze({
@@ -58,71 +68,85 @@ export function canonicalizeSlackTaskPolicy(value: SlackTaskPolicyContent): Slac
   };
 }
 
-export const SlackTaskPolicyRevisionIdentity = z.object({
-  id: z.string().uuid(),
-  revision: z.number().int().positive(),
-  policyHash: z.string().regex(/^[0-9a-f]{64}$/),
-});
+export const SlackTaskPolicyRevisionIdentity = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    revision: primitives.positiveInteger,
+    policyHash: primitives.string.regex(/^[0-9a-f]{64}$/),
+  }),
+);
 export type SlackTaskPolicyRevisionIdentity = z.infer<typeof SlackTaskPolicyRevisionIdentity>;
 
-export const SlackTaskPolicyRevision = SlackTaskPolicyRevisionIdentity.extend({
-  operationId: z.string().uuid(),
-  accountId: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  policy: SlackTaskPolicyContent,
-  supersedesRevisionId: z.string().uuid().nullable(),
-  createdBySubjectId: z.string().min(1).max(1_024),
-  createdAt: z.string().datetime(),
-});
+export const SlackTaskPolicyRevision = /* @__PURE__ */ defineSchema(() =>
+  SlackTaskPolicyRevisionIdentity.extend({
+    operationId: primitives.uuid,
+    accountId: primitives.uuid,
+    workspaceId: primitives.uuid,
+    policy: SlackTaskPolicyContent,
+    supersedesRevisionId: primitives.nullableUuid,
+    createdBySubjectId: z.string().min(1).max(1_024),
+    createdAt: primitives.dateTime,
+  }),
+);
 export type SlackTaskPolicyRevision = z.infer<typeof SlackTaskPolicyRevision>;
 
-export const SlackTaskPolicyHead = z.object({
-  accountId: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  revisionId: z.string().uuid(),
-  revision: z.number().int().positive(),
-  policyHash: z.string().regex(/^[0-9a-f]{64}$/),
-  activationVersion: z.number().int().positive(),
-  activatedAt: z.string().datetime(),
-});
+export const SlackTaskPolicyHead = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    accountId: primitives.uuid,
+    workspaceId: primitives.uuid,
+    revisionId: primitives.uuid,
+    revision: primitives.positiveInteger,
+    policyHash: primitives.string.regex(/^[0-9a-f]{64}$/),
+    activationVersion: primitives.positiveInteger,
+    activatedAt: primitives.dateTime,
+  }),
+);
 export type SlackTaskPolicyHead = z.infer<typeof SlackTaskPolicyHead>;
 
-export const SlackTaskPolicyActivationEvent = z.object({
-  id: z.string().uuid(),
-  operationId: z.string().uuid(),
-  accountId: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  activationVersion: z.number().int().positive(),
-  oldRevision: SlackTaskPolicyRevisionIdentity.nullable(),
-  newRevision: SlackTaskPolicyRevisionIdentity,
-  actorSubjectId: z.string().min(1).max(1_024),
-  reason: z.string().min(1).max(SLACK_TASK_POLICY_REASON_MAX_CHARS),
-  createdAt: z.string().datetime(),
-});
+export const SlackTaskPolicyActivationEvent = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    operationId: primitives.uuid,
+    accountId: primitives.uuid,
+    workspaceId: primitives.uuid,
+    activationVersion: primitives.positiveInteger,
+    oldRevision: SlackTaskPolicyRevisionIdentity.nullable(),
+    newRevision: SlackTaskPolicyRevisionIdentity,
+    actorSubjectId: z.string().min(1).max(1_024),
+    reason: primitives.nonEmptyString.max(SLACK_TASK_POLICY_REASON_MAX_CHARS),
+    createdAt: primitives.dateTime,
+  }),
+);
 export type SlackTaskPolicyActivationEvent = z.infer<typeof SlackTaskPolicyActivationEvent>;
 
-export const SlackTaskPolicyListResponse = z.object({
-  current: SlackTaskPolicyHead.nullable(),
-  activeRevision: SlackTaskPolicyRevision.nullable(),
-  revisions: z.array(SlackTaskPolicyRevision),
-  activationEvents: z.array(SlackTaskPolicyActivationEvent),
-});
+export const SlackTaskPolicyListResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    current: SlackTaskPolicyHead.nullable(),
+    activeRevision: SlackTaskPolicyRevision.nullable(),
+    revisions: z.array(SlackTaskPolicyRevision),
+    activationEvents: z.array(SlackTaskPolicyActivationEvent),
+  }),
+);
 export type SlackTaskPolicyListResponse = z.infer<typeof SlackTaskPolicyListResponse>;
 
-export const UpdateSlackTaskPolicyRequest = z.object({
-  operationId: z.string().uuid().optional(),
-  policy: SlackTaskPolicyContent,
-  expectedCurrentRevisionId: z.string().uuid().nullable(),
-  expectedActivationVersion: z.number().int().nonnegative(),
-  reason: z.string().trim().min(1).max(SLACK_TASK_POLICY_REASON_MAX_CHARS),
-});
+export const UpdateSlackTaskPolicyRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    operationId: primitives.optionalUuid,
+    policy: SlackTaskPolicyContent,
+    expectedCurrentRevisionId: primitives.nullableUuid,
+    expectedActivationVersion: primitives.nonnegativeInteger,
+    reason: primitives.string.trim().min(1).max(SLACK_TASK_POLICY_REASON_MAX_CHARS),
+  }),
+);
 export type UpdateSlackTaskPolicyRequest = z.infer<typeof UpdateSlackTaskPolicyRequest>;
 
-export const SlackTaskPolicyMutationResponse = z.object({
-  revision: SlackTaskPolicyRevision,
-  head: SlackTaskPolicyHead,
-  event: SlackTaskPolicyActivationEvent,
-});
+export const SlackTaskPolicyMutationResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    revision: SlackTaskPolicyRevision,
+    head: SlackTaskPolicyHead,
+    event: SlackTaskPolicyActivationEvent,
+  }),
+);
 export type SlackTaskPolicyMutationResponse = z.infer<typeof SlackTaskPolicyMutationResponse>;
 
 export type SlackTaskPolicyConversationFacts = Readonly<{

package/src/spreadsheet-artifact-commands.ts

@@ -3,6 +3,7 @@ import {
   canonicalSpreadsheetDateMilliseconds,
 } from "./spreadsheet-artifact-date";
 import { SPREADSHEET_ARTIFACT_COMMAND_VERSION } from "./editable-artifact-versions";
+import { fnv1a64 } from "./editable-artifact-binary";
 
 /**
  * Canonical, identity-free spreadsheet mutation commands nested inside
@@ -17,6 +18,9 @@ export const SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS = 4_096;
 export const SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS = 1_000_000;
 export const SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES = 1 * 1024 * 1024;
 export const SPREADSHEET_ARTIFACT_SHEET_NAME_MAX_UTF16_UNITS = 31;
+export const SPREADSHEET_DEFAULT_ROW_HEIGHT = 24;
+export const SPREADSHEET_DEFAULT_COLUMN_WIDTH = 96;
+export const SPREADSHEET_MAX_DIMENSION_PIXELS = 4096;
 
 const MAGIC = new TextEncoder().encode("OGASC002");
 const HEADER_BYTES = 8 + 2 + 2 + 4 + 8;
@@ -26,8 +30,6 @@ const textDecoder = new TextDecoder("utf-8", { fatal: true });
 const LOWER_HEX_ID = /^[0-9a-f]{32}$/u;
 const UINT64_HEX_ZERO = "0".repeat(16);
 const UINT32_MAX = 0xffff_ffff;
-const FNV_OFFSET = 0xcbf29ce484222325n;
-const FNV_PRIME = 0x100000001b3n;
 
 declare const stableIdBrand: unique symbol;
 
@@ -121,7 +123,19 @@ export type SpreadsheetArtifactCommand =
   | SpreadsheetRenameSheetCommand
   | SpreadsheetDeleteSheetCommand
   | SpreadsheetSetCellsCommand
-  | SpreadsheetClearRangeCommand;
+  | SpreadsheetClearRangeCommand
+  | Readonly<{
+      kind: "row.height.set";
+      sheet: SpreadsheetSheetPrecondition;
+      row: number;
+      height: number | null;
+    }>
+  | Readonly<{
+      kind: "column.width.set";
+      sheet: SpreadsheetSheetPrecondition;
+      column: number;
+      width: number | null;
+    }>;
 
 export type SpreadsheetArtifactCommandBatch = Readonly<{
   version: typeof SPREADSHEET_ARTIFACT_COMMAND_VERSION;
@@ -331,6 +345,27 @@ function encodeCommand(
       writer.u32(range.end.column);
       break;
     }
+    case "row.height.set":
+    case "column.width.set": {
+      const row = command.kind === "row.height.set";
+      const coordinate = row ? "row" : "column";
+      const size = row ? "height" : "width";
+      exactKeys(
+        command,
+        ["kind", "sheet", coordinate, size].sort(),
+        `spreadsheet command ${index}`,
+      );
+      writer.u8(row ? 5 : 6);
+      encodeSheetPrecondition(writer, command.sheet, index, context);
+      writer.u32(nonnegativeU32(command[coordinate], coordinate));
+      writer.u32(
+        dimensionPixels(
+          command[size],
+          row ? SPREADSHEET_DEFAULT_ROW_HEIGHT : SPREADSHEET_DEFAULT_COLUMN_WIDTH,
+        ),
+      );
+      break;
+    }
     default:
       throw commandError(index, "unknown command kind");
   }
@@ -341,7 +376,8 @@ function decodeCommand(
   index: number,
   context: CommandContext,
 ): SpreadsheetArtifactCommand {
-  switch (reader.u8()) {
+  const tag = reader.u8();
+  switch (tag) {
     case 0: {
       const sheetId = reader.sheetObjectId();
       const name = decodedSheetName(
@@ -400,11 +436,45 @@ function decodeCommand(
         range: Object.freeze({ start, end }),
       });
     }
+    case 5:
+    case 6: {
+      const sheet = decodeSheetPrecondition(reader, index, context);
+      const coordinate = reader.u32();
+      const pixels = reader.u32();
+      const defaultPixels =
+        tag === 5 ? SPREADSHEET_DEFAULT_ROW_HEIGHT : SPREADSHEET_DEFAULT_COLUMN_WIDTH;
+      if (pixels === defaultPixels || pixels > SPREADSHEET_MAX_DIMENSION_PIXELS) {
+        throw commandError(index, "dimension pixels are noncanonical or outside bounds");
+      }
+      return tag === 5
+        ? Object.freeze({ kind: "row.height.set", sheet, row: coordinate, height: pixels || null })
+        : Object.freeze({
+            kind: "column.width.set",
+            sheet,
+            column: coordinate,
+            width: pixels || null,
+          });
+    }
     default:
       throw commandError(index, "unknown binary command tag");
   }
 }
 
+function dimensionPixels(value: unknown, defaultPixels: number): number {
+  if (value === null) return 0;
+  if (
+    typeof value !== "number" ||
+    !Number.isInteger(value) ||
+    value < 1 ||
+    value > SPREADSHEET_MAX_DIMENSION_PIXELS
+  ) {
+    throw new RangeError(
+      "dimension pixels must be an integer from 1 through 4096, or null to reset",
+    );
+  }
+  return value === defaultPixels ? 0 : value;
+}
+
 function encodeSheetPrecondition(
   writer: BinaryWriter,
   value: unknown,
@@ -651,15 +721,6 @@ function compareCodeUnits(left: string, right: string): number {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-function fnv1a64(bytes: Uint8Array): bigint {
-  let hash = FNV_OFFSET;
-  for (const byte of bytes) {
-    hash ^= BigInt(byte);
-    hash = BigInt.asUintN(64, hash * FNV_PRIME);
-  }
-  return hash;
-}
-
 function equalBytes(left: Uint8Array, right: Uint8Array): boolean {
   return (
     left.byteLength === right.byteLength && left.every((value, index) => value === right[index])