revise 1.0.0 → 2.0.0

package/index.js

@@ -0,0 +1 @@
+import{c8 as s,c7 as a,ca as e,cd as c,cb as r,c9 as o,ca as E,ce as t,cc as R}from"./chunks/index-CLw_BlSL.js";export{s as REVISE_SDK_BUILD,a as REVISE_SDK_VERSION,e as ReviseEditor,c as ReviseRoleError,r as ReviseToolError,o as createEmptyDocx,E as default,t as rolePolicy,R as setAssetBaseUrl};

package/package.json

@@ -1,32 +1,99 @@
 {
-    "name":             "revise",
-    "version":          "1.0.0",
-    "author":           "Alan Gutierrez <alan@prettyrobots.com>",
-    "description":      "Utilities for adding MVCC version numbers to Strata b-tree keys.",
-    "keywords":
-    [
-                        "btree", "leveldb", "levelup", "binary", "mvcc",
-                        "database", "json", "b-tree", "concurrent", "persistence"
-    ],
-    "contributors":     [],
-    "homepage":         "https://bigeasy.github.io/revise",
-    "bugs":             "https://github.com/bigeasy/revise/issues",
-    "license":          "MIT",
-    "repository":
-    {
-                        "type": "git",
-                        "url": "http://github.com/bigeasy/revise.git"
+  "name": "revise",
+  "version": "2.0.0",
+  "description": "A word processor for React: DOCX in and out, real pagination, tracked changes, comments, collaboration, and agent tools. Free for evaluation, personal projects, and education.",
+  "keywords": [
+    "docx",
+    "word",
+    "word-processor",
+    "document-editor",
+    "rich-text-editor",
+    "react",
+    "tracked-changes",
+    "redlines",
+    "comments",
+    "yjs",
+    "ai",
+    "agent"
+  ],
+  "type": "module",
+  "main": "./root.js",
+  "module": "./root.js",
+  "types": "./root.d.ts",
+  "exports": {
+    ".": {
+      "types": "./root.d.ts",
+      "import": "./root.js"
     },
-    "main":             "revise",
-    "dependencies":
-    {
+    "./editor": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
     },
-    "devDependencies":
-    {
-                        "proof":              "1.x"
+    "./editor/full": {
+      "types": "./index.d.ts",
+      "import": "./full.js"
     },
-    "scripts":
-    {
-                        "test": "proof platform win32 && proof test */*/*.t.js || t/test"
+    "./server": {
+      "types": "./backend.d.ts",
+      "import": "./backend.js"
+    },
+    "./style.css": "./style.css",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "root.js",
+    "root.d.ts",
+    "index.js",
+    "index.d.ts",
+    "full.js",
+    "backend.js",
+    "backend.d.ts",
+    "serverToolContract.d.ts",
+    "serverToolInputs.generated.d.ts",
+    "style.css",
+    "chunks",
+    "assets",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md",
+    "FONT-LICENSE-LIBERATION.txt",
+    "FONT-LICENSE-NOTO-SANS-SC.txt",
+    "FONT-LICENSE-NOTO-MULTILINGUAL.txt",
+    "FONT-LICENSE-NOTO.txt",
+    "FONT-LICENSE-HAN-EXT-B.txt",
+    "FONT-LICENSE-SOURCE-SERIF-4.txt",
+    "FONT-LICENSE-SOURCE-CODE-PRO.txt",
+    "FONT-LICENSE-KATEX.txt"
+  ],
+  "sideEffects": [
+    "*.css"
+  ],
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18",
+    "yjs": "^13.6.0",
+    "y-protocols": "^1.0.6",
+    "jsdom": ">=22"
+  },
+  "peerDependenciesMeta": {
+    "jsdom": {
+      "optional": true
     }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://revise.io",
+  "bugs": {
+    "email": "sdk@revise.io",
+    "url": "https://developer.revise.io/editor-sdk/support"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "node -e \"if(process.env.REVISE_SDK_VERIFIED_PUBLISH!=='1'){console.error('Refusing to publish: use npm run publish:sdk in frontend/, which audits the exact tarball first.');process.exit(1)}\""
+  }
 }

package/root.d.ts

@@ -0,0 +1,5 @@
+/** The version of this package, at runtime. */
+export declare const REVISE_SDK_VERSION: string;
+/** The commit this bundle was built from. */
+export declare const REVISE_SDK_BUILD: string;
+export type * from "./index.js";

package/root.js

@@ -0,0 +1,2 @@
+export const REVISE_SDK_VERSION = "2.0.0";
+export const REVISE_SDK_BUILD = "7bebae559";

package/serverToolContract.d.ts

@@ -0,0 +1,373 @@
+/**
+ * The canonical tool contract, shared by both surfaces. The `Server` prefix
+ * marks the headless origin of these types, but since 1.0.0 the browser
+ * surface (`editor.tools`) speaks exactly the same envelope: `execute()`
+ * returns the same discriminated `ReviseToolResult`, `call()` throws the same
+ * `ReviseToolError`, and inputs are typed by the same generated map. Hosts
+ * can share result-handling code between web and Node verbatim.
+ */
+import type {
+  ReviseJsonObject,
+  ReviseJsonValue,
+  ReviseToolInput,
+  ReviseToolName,
+} from "./serverToolInputs.generated.js";
+
+export type {
+  ReviseJsonObject,
+  ReviseJsonPrimitive,
+  ReviseJsonValue,
+  ReviseToolInput,
+  ReviseToolInputMap,
+  ReviseToolName,
+} from "./serverToolInputs.generated.js";
+
+export type ServerDocumentMode = "editing" | "suggesting";
+
+export interface ServerDocumentSessionOptions {
+  documentId: string;
+  /**
+   * Initial mode; the session's mode methods can change it later. Defaults to
+   * "suggesting" — the same posture as the browser surface, and the safe one:
+   * a service proposes tracked changes unless it explicitly opts into
+   * applying edits directly.
+   */
+  mode?: ServerDocumentMode;
+  searchPageSize?: number;
+}
+
+export interface ReviseToolCallOptions {
+  /** Apply this mutation directly, even when the session is suggesting. */
+  directMode?: boolean;
+}
+
+/** Discriminant of a pending tracked-suggestion record. */
+export type ReviseSuggestionType =
+  | "inline-text"
+  | "inline-format"
+  | "block-change"
+  | "block-insert"
+  | "block-delete"
+  | "table-change"
+  | "paragraph-split"
+  | "paragraph-merge";
+
+/**
+ * One pending tracked-suggestion record, projected for host review flows.
+ * Metadata fields are absent when the underlying record predates uniform
+ * authorship stamping or was written by an older client.
+ */
+export interface ReviseSuggestionRecord {
+  id: string;
+  /** Absent when only stamped content marks carry the suggestion, which is
+   * the norm for inline text edits and for restored documents. */
+  type?: ReviseSuggestionType;
+  /** The top-level block the suggestion targets, for block-scoped types. */
+  blockId?: string;
+  /** The table the suggestion targets, for table-change records. */
+  tableId?: string;
+  authorType?: "ai" | "human";
+  /** Author display name: an agent name or a human's display name. */
+  agentName?: string;
+  /** Provider-qualified model that authored an AI suggestion. */
+  agentModel?: string;
+  source?: string;
+  label?: string;
+  createdAt?: number;
+}
+
+/**
+ * Per-ID outcome of an accept or reject call. IDs a host persisted from an
+ * earlier tool result can go stale — a later suggestion can supersede an
+ * earlier one — so the settled and unknown sets are reported explicitly
+ * instead of an inferred count.
+ */
+export interface ReviseSuggestionDecision {
+  /** Requested IDs that were pending and are now settled. */
+  resolved: string[];
+  /** Requested IDs that were not pending suggestions when the call ran. */
+  missing: string[];
+  /** Requested IDs that were pending but could not be settled. Rare. */
+  unresolved: string[];
+}
+
+export interface ReviseToolDefinition<
+  Name extends ReviseToolName = ReviseToolName,
+> {
+  name: Name;
+  description: string;
+  inputSchema: ReviseJsonObject;
+}
+
+export interface ReviseReadCoverage {
+  requestedBlockCount: number;
+  readBlocksThisTurn: number;
+  readTokenBudgetMax: number;
+  requestedRanges: Array<{ start: number; end: number }>;
+  fullDocumentLoaded: boolean;
+}
+
+export interface ReviseReadData {
+  kind: "read_context";
+  tool: "read_blocks_from_index" | "read_specific_blocks";
+  loaded: ReviseJsonObject;
+  next: { index: number; blockId?: string } | null;
+  endOfDocument: boolean;
+  coverage: ReviseReadCoverage;
+}
+
+export interface ReviseSearchMatch {
+  blockId: string;
+  blockIndex: number;
+  matchedQueries?: string[];
+  matchedColors?: string[];
+}
+
+export interface ReviseSearchData {
+  kind: "search_context";
+  tool: "search_document" | "find_highlights";
+  queries?: string[];
+  color?: string;
+  totalMatches: number;
+  search_result_id?: string;
+  page: {
+    current: number;
+    total: number;
+    startResult: number;
+    endResult: number;
+  };
+  nextPage: number | null;
+  matches: ReviseSearchMatch[];
+  coverage: ReviseReadCoverage;
+}
+
+export interface ReviseDocumentMeasurementSection {
+  startIndex: number;
+  endIndex: number;
+  startBlockId: string;
+  endBlockId: string;
+  headingLevel: 1 | 2 | 3;
+  title: string;
+  wordCount: number;
+  paragraphCount: number;
+  characterCount: number;
+  inclusive: true;
+  blockCount: number;
+  pageStart?: number;
+  pageEnd?: number;
+}
+
+export interface ReviseDocumentMeasurementData {
+  kind: "document_measurement";
+  tool: "measure_document";
+  inclusive: true;
+  totalBlocks: number;
+  wordCount: number;
+  paragraphCount: number;
+  characterCount: number;
+  pageCount?: number;
+  fractionalPageCount?: number;
+  sections?: ReviseDocumentMeasurementSection[];
+  sectionCount?: number;
+  sectionOffset?: number;
+  sectionLimit?: number;
+  returnedSectionCount?: number;
+  hasMoreSections?: boolean;
+  nextSectionOffset?: number;
+}
+
+export interface ReviseMeasuredBlockRange {
+  startIndex: number;
+  endIndex: number;
+  startBlockId: string;
+  endBlockId: string;
+  inclusive: true;
+  blockCount: number;
+  wordCount: number;
+  paragraphCount: number;
+  characterCount: number;
+  pageStart?: number;
+  pageEnd?: number;
+}
+
+export interface ReviseBlockMeasurementData {
+  kind: "document_measurement";
+  tool: "measure_blocks";
+  inclusive: true;
+  totalBlocks: number;
+  ranges: ReviseMeasuredBlockRange[];
+  errors: Array<{
+    startBlockId?: string;
+    endBlockId?: string;
+    error: string;
+  }>;
+}
+
+export interface ReviseMutationData {
+  tool: string;
+  target_reference?: string;
+  summary?: string;
+  effect: {
+    requested_target_count: number;
+    changed_target_count: number;
+    removed_target_count: number;
+    inserted_block_count: number;
+    top_level_blocks_before: number;
+    top_level_blocks_after: number;
+    [key: string]: ReviseJsonValue;
+  };
+  before_block?: string;
+}
+
+export interface ReviseCommentData {
+  commentId: string;
+  blockId: string;
+  anchor: ReviseJsonObject;
+}
+
+type ReviseReadToolName = "read_blocks_from_index" | "read_specific_blocks";
+type ReviseSearchToolName = "search_document" | "find_highlights";
+type ReviseMeasurementToolName = "measure_document" | "measure_blocks";
+type ReviseSpecializedToolName =
+  | ReviseReadToolName
+  | ReviseSearchToolName
+  | ReviseMeasurementToolName
+  | "leave_comment";
+type ReviseMutationToolName = Exclude<
+  ReviseToolName,
+  ReviseSpecializedToolName
+>;
+
+export type ReviseToolDataMap = {
+  [Name in ReviseReadToolName]: ReviseReadData;
+} & {
+  [Name in ReviseSearchToolName]: ReviseSearchData;
+} & {
+  measure_document: ReviseDocumentMeasurementData;
+  measure_blocks: ReviseBlockMeasurementData;
+  leave_comment: ReviseCommentData;
+} & {
+  [Name in ReviseMutationToolName]: ReviseMutationData | null;
+};
+
+export type ReviseToolData<Name extends ReviseToolName> =
+  ReviseToolDataMap[Name];
+
+/** Tool arguments, with input optional only when its schema has no required fields. */
+export type ReviseToolArguments<Name extends ReviseToolName> =
+  Record<string, never> extends ReviseToolInput<Name>
+    ? [input?: ReviseToolInput<Name>, options?: ReviseToolCallOptions]
+    : [input: ReviseToolInput<Name>, options?: ReviseToolCallOptions];
+
+/** Semantic document context returned by read and search calls. */
+export interface ReviseDocumentContext {
+  format: "revise-html";
+  html: string;
+}
+
+/** A successful tool call, ready for application code or a model transcript. */
+export interface ReviseToolResponse<Name extends string = ReviseToolName> {
+  callId: string;
+  tool: Name;
+  /** Concise model-oriented summary of what happened. */
+  message: string | null;
+  /** Tool-specific structured data. Literal tool names infer this type. */
+  data: Name extends ReviseToolName
+    ? ReviseToolData<Name>
+    : ReviseJsonValue | null;
+  /** Block-ID-preserving semantic HTML, when the call loaded document text. */
+  context: ReviseDocumentContext | null;
+  /**
+   * For mutation tools, the tracked suggestion records this call created:
+   * non-empty only in suggesting mode. Empty when the edit applied directly,
+   * changed nothing, or extended an existing pending suggestion instead of
+   * creating its own record. Null for read, search, and measurement tools.
+   */
+  suggestionIds: string[] | null;
+  /**
+   * Image payload from browser-only tools (`view_image`). Never present on
+   * the server surface, whose sessions exclude the image pipeline.
+   */
+  image?: {
+    id: string;
+    fileName?: string;
+    urls?: string[];
+    dimensions?: Array<{ width: number; height: number }>;
+  };
+}
+
+/** An expected tool rejection: invalid input, stale context, or unavailable tool. */
+export interface ReviseToolFailure<Name extends string = ReviseToolName> {
+  callId: string;
+  tool: Name;
+  code: string;
+  message: string;
+}
+
+export type ReviseToolResult<Name extends string = ReviseToolName> =
+  | { ok: true; value: ReviseToolResponse<Name> }
+  | { ok: false; error: ReviseToolFailure<Name> };
+
+export interface ServerDocumentTools {
+  getDefinitions(): ReviseToolDefinition[];
+
+  /**
+   * Execute a known tool and preserve expected failures as a discriminated
+   * result. Environment and disposed-session errors still reject the promise.
+   */
+  execute<Name extends ReviseToolName>(
+    name: Name,
+    ...args: ReviseToolArguments<Name>
+  ): Promise<ReviseToolResult<Name>>;
+
+  /** Execute an untrusted model-provided name and JSON input. */
+  executeDynamic(
+    name: string,
+    input?: ReviseJsonObject,
+    options?: ReviseToolCallOptions,
+  ): Promise<ReviseToolResult<string>>;
+
+  /**
+   * Convenient application-code form. Returns only the successful response
+   * and throws ReviseToolError when the tool rejects the call.
+   */
+  call<Name extends ReviseToolName>(
+    name: Name,
+    ...args: ReviseToolArguments<Name>
+  ): Promise<ReviseToolResponse<Name>>;
+}
+
+export interface ServerDocumentSession {
+  /** Return the mode subsequent mutations will capture. */
+  getMode(): ServerDocumentMode;
+  /** Make subsequent mutations produce tracked suggestions. */
+  setSuggestingMode(): void;
+  /** Make subsequent mutations apply directly. */
+  setEditingMode(): void;
+  readonly tools: ServerDocumentTools;
+  /** IDs of pending tracked suggestions currently stored in the Y.Doc. */
+  getPendingSuggestionIds(): string[];
+  /**
+   * Every pending tracked suggestion in the Y.Doc as a reviewable record —
+   * including collaborators' suggestions in a shared document. Filter by
+   * author metadata before making bulk decisions on someone else's work.
+   */
+  listSuggestions(): ReviseSuggestionRecord[];
+  /**
+   * Accept specific pending suggestions by ID — the primary review path.
+   * Collect IDs from mutation results' `suggestionIds` or from
+   * `listSuggestions()`.
+   */
+  acceptSuggestions(suggestionIds: string[]): ReviseSuggestionDecision;
+  /** Reject specific pending suggestions by ID. */
+  rejectSuggestions(suggestionIds: string[]): ReviseSuggestionDecision;
+  /**
+   * Accept every pending suggestion in the Y.Doc, including collaborators'.
+   * Prefer `acceptSuggestions(ids)` unless the host owns the whole document.
+   */
+  acceptAllSuggestions(): ReviseSuggestionDecision;
+  /** Reject every pending suggestion in the Y.Doc, including collaborators'. */
+  rejectAllSuggestions(): ReviseSuggestionDecision;
+  /** Release observers without destroying the supplied Y.Doc. */
+  dispose(): void;
+}