@powerhousedao/shared 6.2.3-dev.9 → 6.2.3-staging.0

package/dist/document-model/mock.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 //#region document-model/mock.d.ts
 /**
  * Builds a mock value for a schema, with `overrides` taking precedence.
@@ -16,7 +15,7 @@ import { z } from "zod";
  * override still throws, which is correct: there is no way to invent a value
  * for it, and the caller needs to say what it should be.
  */
-declare function generateMock<TSchema extends z.ZodType>(schema: TSchema, overrides?: Partial<z.infer<TSchema>>): z.infer<TSchema>;
+export declare function generateMock<TSchema extends z.ZodType>(schema: TSchema, overrides?: Partial<z.infer<TSchema>>): z.infer<TSchema>;
 //#endregion
-export { generateMock };
+export {};
 //# sourceMappingURL=mock.d.ts.map

package/dist/document-model/mock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock.d.ts","names":[],"sources":["../../document-model/mock.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;iBAAgB,YAAA,iBAA6B,CAAA,CAAE,OAAA,CAAA,CAC7C,MAAA,EAAQ,OAAA,EACR,SAAA,GAAY,OAAA,CAAQ,CAAA,CAAE,KAAA,CAAM,OAAA,KAC3B,CAAA,CAAE,KAAA,CAAM,OAAA"}
+{"version":3,"file":"mock.d.ts","names":[],"sources":["../../document-model/mock.ts"],"mappings":";;;;;;;;;;;;;;;;;wBA0BgB,aAAa,gBAAgB,EAAE,SAC7C,QAAQ,SACR,YAAY,QAAQ,EAAE,MAAM,YAC3B,EAAE,MAAM"}

package/dist/document-model/mock.js

@@ -32,8 +32,9 @@ function generateMock(schema, overrides) {
 	};
 	const omittable = overriddenKeys.filter((key) => key in schema.shape);
 	const mask = Object.fromEntries(omittable.map((key) => [key, true]));
+	const schemaToGenerate = omittable.length ? schema.omit(mask) : schema;
 	return {
-		...zocker(omittable.length ? schema.omit(mask) : schema).generate(),
+		...zocker(schemaToGenerate).generate(),
 		...overrides
 	};
 }

package/dist/document-model/mock.js.map

@@ -1 +1 @@
-{"version":3,"file":"mock.js","names":[],"sources":["../../document-model/mock.ts"],"sourcesContent":["import { zocker } from \"zocker\";\nimport { z } from \"zod\";\n\n/**\n * Narrows to an object schema whose shape we can omit keys from. Callers may\n * pass any `ZodType`, so this has to be checked rather than assumed.\n */\nfunction isObjectSchema(schema: z.ZodType): schema is z.ZodObject {\n  return schema instanceof z.ZodObject;\n}\n\n/**\n * Builds a mock value for a schema, with `overrides` taking precedence.\n *\n * Overridden fields are removed from the schema *before* generation rather than\n * being overwritten afterwards. That ordering is what makes overrides usable as\n * an escape hatch: some scalars compile to `z.custom(...)` (`AttachmentRef`,\n * `Address`), and zocker cannot synthesise a value satisfying an arbitrary\n * predicate — it throws. Generating first meant the throw happened before the\n * caller's value was ever applied, so an override could not rescue the field it\n * was written for.\n *\n * Only the overridden keys are skipped. A `z.custom(...)` field with no\n * override still throws, which is correct: there is no way to invent a value\n * for it, and the caller needs to say what it should be.\n */\nexport function generateMock<TSchema extends z.ZodType>(\n  schema: TSchema,\n  overrides?: Partial<z.infer<TSchema>>,\n): z.infer<TSchema> {\n  if (!overrides) return zocker(schema).generate() as z.infer<TSchema>;\n\n  const overriddenKeys = Object.keys(overrides);\n  if (overriddenKeys.length === 0 || !isObjectSchema(schema)) {\n    // Nothing to skip, or a schema with no shape to omit from: generate the\n    // whole value and let the overrides win by merge, as before.\n    const generated = zocker(schema).generate() as z.infer<TSchema>;\n    return { ...(generated as object), ...overrides } as z.infer<TSchema>;\n  }\n\n  // Omitting a key the shape does not have is an error in zod, and an override\n  // for an unknown key should still pass through to the result.\n  const omittable = overriddenKeys.filter((key) => key in schema.shape);\n  // `omit` is typed against the shape's literal keys; ours are only known at\n  // runtime, so the mask has to be asserted into that parameter type.\n  const mask = Object.fromEntries(\n    omittable.map((key) => [key, true]),\n  ) as Parameters<typeof schema.omit>[0];\n  const schemaToGenerate = omittable.length ? schema.omit(mask) : schema;\n\n  const generated = zocker(schemaToGenerate).generate() as object;\n  return { ...generated, ...overrides } as z.infer<TSchema>;\n}\n"],"mappings":";;;;;;;AAOA,SAAS,eAAe,QAA0C;AAChE,QAAO,kBAAkB,EAAE;;;;;;;;;;;;;;;;;AAkB7B,SAAgB,aACd,QACA,WACkB;AAClB,KAAI,CAAC,UAAW,QAAO,OAAO,OAAO,CAAC,UAAU;CAEhD,MAAM,iBAAiB,OAAO,KAAK,UAAU;AAC7C,KAAI,eAAe,WAAW,KAAK,CAAC,eAAe,OAAO,CAIxD,QAAO;EAAE,GADS,OAAO,OAAO,CAAC,UAAU;EACR,GAAG;EAAW;CAKnD,MAAM,YAAY,eAAe,QAAQ,QAAQ,OAAO,OAAO,MAAM;CAGrE,MAAM,OAAO,OAAO,YAClB,UAAU,KAAK,QAAQ,CAAC,KAAK,KAAK,CAAC,CACpC;AAID,QAAO;EAAE,GADS,OAFO,UAAU,SAAS,OAAO,KAAK,KAAK,GAAG,OAEtB,CAAC,UAAU;EAC9B,GAAG;EAAW"}
+{"version":3,"file":"mock.js","names":[],"sources":["../../document-model/mock.ts"],"sourcesContent":["import { zocker } from \"zocker\";\nimport { z } from \"zod\";\n\n/**\n * Narrows to an object schema whose shape we can omit keys from. Callers may\n * pass any `ZodType`, so this has to be checked rather than assumed.\n */\nfunction isObjectSchema(schema: z.ZodType): schema is z.ZodObject {\n  return schema instanceof z.ZodObject;\n}\n\n/**\n * Builds a mock value for a schema, with `overrides` taking precedence.\n *\n * Overridden fields are removed from the schema *before* generation rather than\n * being overwritten afterwards. That ordering is what makes overrides usable as\n * an escape hatch: some scalars compile to `z.custom(...)` (`AttachmentRef`,\n * `Address`), and zocker cannot synthesise a value satisfying an arbitrary\n * predicate — it throws. Generating first meant the throw happened before the\n * caller's value was ever applied, so an override could not rescue the field it\n * was written for.\n *\n * Only the overridden keys are skipped. A `z.custom(...)` field with no\n * override still throws, which is correct: there is no way to invent a value\n * for it, and the caller needs to say what it should be.\n */\nexport function generateMock<TSchema extends z.ZodType>(\n  schema: TSchema,\n  overrides?: Partial<z.infer<TSchema>>,\n): z.infer<TSchema> {\n  if (!overrides) return zocker(schema).generate() as z.infer<TSchema>;\n\n  const overriddenKeys = Object.keys(overrides);\n  if (overriddenKeys.length === 0 || !isObjectSchema(schema)) {\n    // Nothing to skip, or a schema with no shape to omit from: generate the\n    // whole value and let the overrides win by merge, as before.\n    const generated = zocker(schema).generate() as z.infer<TSchema>;\n    return { ...(generated as object), ...overrides } as z.infer<TSchema>;\n  }\n\n  // Omitting a key the shape does not have is an error in zod, and an override\n  // for an unknown key should still pass through to the result.\n  const omittable = overriddenKeys.filter((key) => key in schema.shape);\n  // `omit` is typed against the shape's literal keys; ours are only known at\n  // runtime, so the mask has to be asserted into that parameter type.\n  const mask = Object.fromEntries(\n    omittable.map((key) => [key, true]),\n  ) as Parameters<typeof schema.omit>[0];\n  const schemaToGenerate = omittable.length ? schema.omit(mask) : schema;\n\n  const generated = zocker(schemaToGenerate).generate() as object;\n  return { ...generated, ...overrides } as z.infer<TSchema>;\n}\n"],"mappings":";;;;;;;AAOA,SAAS,eAAe,QAA0C;CAChE,OAAO,kBAAkB,EAAE;AAC7B;;;;;;;;;;;;;;;;AAiBA,SAAgB,aACd,QACA,WACkB;CAClB,IAAI,CAAC,WAAW,OAAO,OAAO,MAAM,CAAC,CAAC,SAAS;CAE/C,MAAM,iBAAiB,OAAO,KAAK,SAAS;CAC5C,IAAI,eAAe,WAAW,KAAK,CAAC,eAAe,MAAM,GAIvD,OAAO;EAAE,GADS,OAAO,MAAM,CAAC,CAAC,SACZ;EAAc,GAAG;CAAU;CAKlD,MAAM,YAAY,eAAe,QAAQ,QAAQ,OAAO,OAAO,KAAK;CAGpE,MAAM,OAAO,OAAO,YAClB,UAAU,KAAK,QAAQ,CAAC,KAAK,IAAI,CAAC,CACpC;CACA,MAAM,mBAAmB,UAAU,SAAS,OAAO,KAAK,IAAI,IAAI;CAGhE,OAAO;EAAE,GADS,OAAO,gBAAgB,CAAC,CAAC,SACvB;EAAG,GAAG;CAAU;AACtC"}

package/dist/document-model/utils.d.ts

@@ -1,2 +1,3 @@
-import { n as generateId, r as generateMock, t as deriveOperationId } from "../utils-DP122OSS.js";
-export { deriveOperationId, generateId, generateMock };
+import { n as generateId, r as generateMock, t as deriveOperationId } from "../utils-BrKxCmKx.js";
+export { deriveOperationId, generateId, generateMock };
+export {};

package/dist/document-model/utils.js

@@ -1,2 +1,2 @@
-import { n as generateId, r as generateMock, t as deriveOperationId } from "../utils-aaTmfxFW.js";
+import { n as generateId, r as generateMock, t as deriveOperationId } from "../utils-CSF716ux.js";
 export { deriveOperationId, generateId, generateMock };

package/dist/index-5gwOhPG5.d.ts

@@ -0,0 +1,36 @@
+import "./types-CI3ren9F.js";
+import { SignaturePolicy } from "@powerhousedao/shared/document-model";
+import { DocumentDriveLocalState, Node } from "@powerhousedao/shared/document-drive";
+//#region document-drive/src/types.d.ts
+type GenerateNodesCopySrc = {
+  srcId: Node["id"];
+  targetName?: Node["name"];
+  targetParentFolder?: Node["parentFolder"];
+};
+type GenerateNodesCopyIdGenerator = (nodeToCopy: Node) => Node["id"];
+type DriveInput = {
+  global: {
+    name: string;
+    icon?: string | null;
+  };
+  id?: string;
+  slug?: string;
+  preferredEditor?: string;
+  local?: Partial<DocumentDriveLocalState>;
+  /** Merged over the drive's defaults; `signature: 2` makes it v2-required. */
+  protocolVersions?: {
+    [protocol: string]: number;
+  };
+  /** Overrides the client's creation default for this drive. */
+  signaturePolicy?: SignaturePolicy;
+};
+type SharingType = "LOCAL" | "CLOUD" | "PUBLIC";
+//#endregion
+//#region git.d.ts
+declare const GITHUB_REPO_URL = "https://github.com/powerhouse-inc/powerhouse";
+declare function buildTreeUrl(sha: string): string | null;
+declare function shortGitSha(sha: string): string;
+//#endregion
+export { GenerateNodesCopyIdGenerator as a, DriveInput as i, buildTreeUrl as n, GenerateNodesCopySrc as o, shortGitSha as r, SharingType as s, GITHUB_REPO_URL as t };
+export {};
+//# sourceMappingURL=index-5gwOhPG5.d.ts.map

package/dist/index-5gwOhPG5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-5gwOhPG5.d.ts","names":[],"sources":["../document-drive/src/types.ts","../git.ts"],"mappings":";;;;KAMY;EACV,OAAO;EACP,aAAa;EACb,qBAAqB;;KAGX,gCAAgC,YAAY,SAAS;KAErD;EACV;IACE;IACA;;EAEF;EACA;EACA;EACA,QAAQ,QAAQ;;EAEhB;KAAsB;;;EAEtB,kBAAkB;;KAGR;;;cC7BC;iBAEG,aAAa;iBAKb,YAAY"}

package/dist/{index-DP3QgHTq.d.ts → index-D6833Siv.d.ts}

@@ -1,6 +1,6 @@
-import { $t as DocumentModelOperationExampleOperations, Aa as SigningParameters, Bn as ModuleSpecification, Bt as DocumentModelGlobalState, Fu as Operation, Gt as DocumentModelLocalState, H as ActionSignatureContext, Ht as DocumentModelHeaderOperations, Iu as OperationContext, Jl as PHDocumentHeader, Jr as PruneActionInput, Jt as DocumentModelModuleOperations, Ju as Condition, Ku as AuthGroups, Lr as OperationErrorSpecification, Ma as SkipHeaderOperations, Nc as Action, On as LoadFromInput, Pa as StateReducer, Pu as DocumentOperations, Qa as UpgradeManifest, Qu as PHBaseState, Rt as DocumentModelDocument, Sn as ISigner, Ta as SignalDispatch, Yu as Grant, Za as ValidationError, Zt as DocumentModelOperationErrorOperations, Zu as PHAuthState, _i as ReplayDocumentOptions, bi as SaveToFileHandle, cn as DocumentSpecification, ct as Author, ei as Reducer, en as DocumentModelOperationOperations, lt as CodeExample, mn as FileInput, on as DocumentModelVersioningOperations, ql as PHDocument, rn as DocumentModelStateOperations, ti as ReducerOptions, tn as DocumentModelPHState, zn as MinimalBackupData, zr as OperationSpecification } from "./types-BIoOWpOT.js";
+import { Bu as PHBaseState, Ca as SkipHeaderOperations, Cn as ISigner, Ha as ValidationError, In as MinimalBackupData, Iu as Condition, Jr as ReducerOptions, Kl as PHDocument, Kt as DocumentModelLocalState, Ln as ModuleSpecification, Lu as Grant, Mr as OperationErrorSpecification, Pc as Action, Pr as OperationSpecification, Pu as AuthGroups, Qt as DocumentModelOperationErrorOperations, Ta as StateReducer, U as ActionSignatureContext, Ua as UpgradeManifest, Ut as DocumentModelHeaderOperations, Vt as DocumentModelGlobalState, Yt as DocumentModelModuleOperations, _d as Operation, ad as ProtocolVersions, cd as SignaturePolicy, en as DocumentModelOperationExampleOperations, ga as SignalDispatch, gd as DocumentOperations, hn as FileInput, in as DocumentModelStateOperations, kn as LoadFromInput, ln as DocumentSpecification, lt as Author, nn as DocumentModelPHState, pi as SaveToFileHandle, ql as PHDocumentHeader, qr as Reducer, sn as DocumentModelVersioningOperations, tn as DocumentModelOperationOperations, ui as ReplayDocumentOptions, ut as CodeExample, vd as OperationContext, xa as SigningParameters, zt as DocumentModelDocument, zu as PHAuthState } from "./types-CmeoQg_J.js";
+import "./utils-BrKxCmKx.js";
 import { ZodIssue, z } from "zod";
-
 //#region document-model/action-transport.d.ts
 /**
  * An action's signer, as the wire declares it: signatures joined into strings,
@@ -67,7 +67,8 @@ type RemoveGrantActionInput = {
   id: string;
 };
 type MoveGrantActionInput = {
-  id: string; /** Target index in the grant list; clamped to the valid range. */
+  id: string;
+  /** Target index in the grant list; clamped to the valid range. */
   index: number;
 };
 type InitializeAuthAction = Action & {
@@ -157,12 +158,12 @@ declare function assertAuthPreservedOnDuplicate(documentId: string, source: PHAu
  * The auth scope a state snapshot may install, given the policy already there.
  *
  * `applyAuthAction` is the validated door onto `state.auth`, but a whole-state
- * snapshot (UPGRADE_DOCUMENT's `initialState`, LOAD_STATE's `data`) replaces the
- * scope wholesale and is authorized as a `document`-scope write. Without this,
- * a subject holding `execute` on `document` and no auth grant at all can install
- * a policy of its choosing, name itself `creator` (which exempts the policy from
- * the retention rule for good), or wipe an existing policy by carrying the
- * default uninitialized one.
+ * snapshot (UPGRADE_DOCUMENT's `initialState`) replaces the scope wholesale and
+ * is authorized as a `document`-scope write. Without this, a subject holding
+ * `execute` on `document` and no auth grant at all can install a policy of its
+ * choosing, name itself `creator` (which exempts the policy from the retention
+ * rule for good), or wipe an existing policy by carrying the default
+ * uninitialized one.
  *
  * Three cases:
  *
@@ -176,16 +177,19 @@ declare function assertAuthPreservedOnDuplicate(documentId: string, source: PHAu
  *     an attempt to replace one policy with another.
  */
 declare function resolveSnapshotAuth(documentId: string, documentType: string, current: PHAuthState | undefined, incoming: PHAuthState | undefined): PHAuthState;
-/** UNDO, REDO and PRUNE are rejected on the auth scope. */
+/** UNDO and REDO are rejected on the auth scope. */
 declare function assertAuthScopeActionAllowed(action: Action): void;
 type AuthVerb = "read" | "execute";
 type AuthRequest = {
   verb: AuthVerb;
-  scope: string; /** For execute: the operation (action type) being attempted. Omitted for reads. */
+  scope: string;
+  /** For execute: the operation (action type) being attempted. Omitted for reads. */
   operation?: string;
 };
 type AuthSubject = {
-  /** Verified signer address; undefined for an anonymous subject. */address?: string; /** The signer's app key (a did:key), used to match the document creator. */
+  /** Verified signer address; undefined for an anonymous subject. */
+  address?: string;
+  /** The signer's app key (a did:key), used to match the document creator. */
   key?: string;
 };
 /**
@@ -194,7 +198,9 @@ type AuthSubject = {
  * carrying `where` or a { match } principal never applies.
  */
 type ConditionContext = {
-  /** The executing scope's own state, for `doc.<scope>.*` paths. */scopeState: unknown; /** The action's input, for `action.input.*` paths. Absent for reads. */
+  /** The executing scope's own state, for `doc.<scope>.*` paths. */
+  scopeState: unknown;
+  /** The action's input, for `action.input.*` paths. Absent for reads. */
   actionInput?: unknown;
 };
 type AuthDecision = "allow" | "deny";
@@ -345,12 +351,7 @@ declare const HASH_ENCODING_HEX = "hex";
 //#region document-model/crypto.d.ts
 declare const hashBrowser: (data: string | Uint8Array | ArrayBufferView | DataView, algorithm?: string, encoding?: string, _params?: Record<string, unknown>) => string;
 declare function getUnixTimestamp(date: Date | string): string;
-declare function buildOperationSignatureParams({
-  documentId,
-  signer,
-  action,
-  previousStateHash
-}: ActionSignatureContext): [string, string, string, string];
+declare function buildOperationSignatureParams({ documentId, signer, action, previousStateHash }: ActionSignatureContext): [string, string, string, string];
 declare function buildOperationSignatureMessage(params: [string, string, string, string]): Uint8Array;
 declare function ab2hex(ab: ArrayBuffer | ArrayBufferView): string;
 declare function hex2ab(hex: string): Uint8Array<ArrayBuffer>;
@@ -359,6 +360,8 @@ declare function hex2ab(hex: string): Uint8Array<ArrayBuffer>;
  * any character outside the alphabet.
  */
 declare function base58Decode(input: string): Uint8Array | null;
+/** Encodes bytes as unpadded base64url. */
+declare function bytesToBase64Url(bytes: Uint8Array): string;
 /** Decodes a base64url string to bytes (portable across node, browsers, workers). */
 declare function base64UrlToBytes(input: string): Uint8Array;
 //#endregion
@@ -513,7 +516,7 @@ declare class GrantNotFoundError extends Error {
   constructor(grantId: string);
 }
 /**
- * Thrown when a disallowed action (UNDO, REDO, PRUNE) targets the auth scope.
+ * Thrown when a disallowed action (UNDO, REDO) targets the auth scope.
  */
 declare class AuthActionNotAllowedError extends Error {
   readonly actionType: string;
@@ -580,7 +583,8 @@ declare function baseSaveToFileHandle(document: PHDocument, input: FileSystemFil
 declare function baseLoadFromInput<TState extends PHBaseState>(input: FileInput, reducer: Reducer<TState>, options?: ReplayDocumentOptions): Promise<PHDocument<TState>>;
 declare function baseLoadFromInputVersioned<TState extends PHBaseState>(input: FileInput, config: VersionedReplayConfig, options?: ReplayDocumentOptions): Promise<PHDocument<TState>>;
 type BulkArchiveEntry = {
-  /** "/"-separated zip path of a file entry (no trailing slash). */path: string;
+  /** "/"-separated zip path of a file entry (no trailing slash). */
+  path: string;
   data: Uint8Array;
 };
 /**
@@ -647,9 +651,20 @@ declare const validateHeader: (header: PHDocumentHeader) => Promise<void>;
  * Creates a header that has yet to be signed. This header is not valid, but
  * can be input into {@link createSignedHeader} to create a signed header.
  *
+ * With `protocolVersions` requiring v2 signatures the header takes a random
+ * nonce and the id {@link deriveDocumentId} gives, so `id` must be omitted.
+ *
  * @returns An unsigned header for a document.
  */
-declare const createPresignedHeader: (id?: string, documentType?: string) => PHDocumentHeader;
+declare const createPresignedHeader: (id?: string, documentType?: string, protocolVersions?: ProtocolVersions) => PHDocumentHeader;
+/**
+ * A header for a copy of a document headed `source`. A copy is v2-required
+ * when its source is or when `policy` asks for it, and then takes a derived id;
+ * otherwise it takes `id`. It keeps the source's other protocol versions.
+ */
+declare function createCopyHeader(source: Pick<PHDocumentHeader, "documentType" | "protocolVersions">, id?: string, policy?: SignaturePolicy): PHDocumentHeader;
+/** Whether a v2-required `header` carries the id its params derive. */
+declare function hasDerivedDocumentId(header: PHDocumentHeader): boolean;
 /**
  * Creates a new, signed header for a document. This will replace the id of the
  * document.
@@ -673,6 +688,95 @@ declare const createSignedHeader: (unsignedHeader: PHDocumentHeader, documentTyp
  */
 declare const createSignedHeaderForSigner: (documentType: string, signer: ISigner) => Promise<PHDocumentHeader>;
 //#endregion
+//#region document-model/peer-agreement.d.ts
+/** The reactor feature flags a capability's support is a function of. */
+type PeerCapabilityFlags = {
+  readonly [flag: string]: boolean | undefined;
+};
+/** A document protocol, named by its `protocolVersions` key. */
+type ProtocolCapability = {
+  kind: "protocol";
+  name: string;
+  /** What a peer that announces nothing is assumed to support. */
+  baseline: readonly number[];
+  supported(flags: PeerCapabilityFlags): readonly number[];
+  /** The version new documents take when peers agree. Absent: not negotiated. */
+  preferred?(flags: PeerCapabilityFlags): number;
+  /** A header may omit the key. */
+  optional: boolean;
+};
+/** A feature that changes what a peer sends or expects on the wire. */
+type FeatureCapability = {
+  kind: "feature";
+  name: string;
+  baseline: readonly number[];
+  supported(flags: PeerCapabilityFlags): readonly number[];
+};
+type PeerCapability = ProtocolCapability | FeatureCapability;
+declare const PEER_CAPABILITIES: readonly PeerCapability[];
+/** `base` plus `extra`; an extra replaces a base entry of the same name. */
+declare function mergePeerCapabilities(base: readonly PeerCapability[], extra: readonly PeerCapability[]): PeerCapability[];
+declare const PEER_MANIFEST_FORMAT = 1;
+type Supports = {
+  protocols: {
+    [protocol: string]: readonly number[];
+  };
+  features: {
+    [feature: string]: readonly number[];
+  };
+};
+type PeerManifest = Supports & {
+  format: 1;
+  /** The signer's did:key, when configured; informational. */
+  appKey?: string;
+  /** Grows with every start of the reactor; a peer ignores an older one. */
+  sequence: number;
+  /** base64url(sha256(canonicalJson(Supports & { sequence }))) */
+  revision: string;
+};
+/** What this reactor supports, for every capability it registers. */
+declare function localSupports(capabilities: readonly PeerCapability[], flags: PeerCapabilityFlags): Supports;
+/** What a peer that announces nothing supports. */
+declare function legacySupports(capabilities: readonly PeerCapability[]): Supports;
+declare function manifestRevision(supports: Supports, sequence?: number): string;
+declare function localPeerManifest(capabilities: readonly PeerCapability[], flags: PeerCapabilityFlags, appKey?: string, sequence?: number): PeerManifest;
+/** A manifest sent before the one already held; silence carries no sequence. */
+declare function isOlderManifest(next: PeerManifest | null, held: PeerManifest | null | undefined): boolean;
+/** A peer's manifest, or the baselines for a peer that announced none. */
+declare function peerSupports(manifest: PeerManifest | null, capabilities: readonly PeerCapability[]): Supports;
+/**
+ * A manifest as received from a peer, or null when it is not one. Formats only
+ * add fields, so one of an unknown format is read as its two maps.
+ */
+declare function readPeerManifest(value: unknown): PeerManifest | null;
+/** Why a document may not go to a peer. */
+type HoldReason = {
+  protocol: string;
+  version: number;
+  peerSupports: readonly number[];
+};
+/** Only keys this reactor registers are judged; an absent key agrees. */
+declare function holdReason(peer: Supports, versions: {
+  readonly [protocol: string]: number;
+}, capabilities: readonly PeerCapability[]): HoldReason | undefined;
+/** Whether a peer runs every version this reactor does, so nothing is held. */
+declare function coversLocal(peer: Supports, local: Supports, capabilities: readonly PeerCapability[]): boolean;
+/**
+ * protocolVersions for a new document: per negotiated protocol, the highest
+ * version up to the local preference that every member supports, else the
+ * lowest local one. `requested` wins over what is selected.
+ */
+declare function selectProtocolVersions(input: {
+  capabilities: readonly PeerCapability[];
+  flags: PeerCapabilityFlags;
+  members: Iterable<Supports>;
+  requested?: {
+    readonly [protocol: string]: number;
+  };
+}): {
+  [protocol: string]: number;
+};
+//#endregion
 //#region document-model/reducer.d.ts
 declare function replayOperations<TState extends PHBaseState = PHBaseState>(initialState: TState, clearedOperations: DocumentOperations, stateReducer: StateReducer<TState>, header: PHDocumentHeader, dispatch?: SignalDispatch, documentReducer?: typeof baseReducer, skipHeaderOperations?: SkipHeaderOperations, options?: ReplayDocumentOptions): PHDocument<TState>;
 /**
@@ -702,7 +806,7 @@ declare function processUndoRedo<TState extends PHBaseState = PHBaseState>(docum
 };
 /**
  * Base document reducer that wraps a custom document reducer and handles
- * document-level actions such as undo, redo, prune, and set name.
+ * document-level actions such as undo, redo, and set name.
  *
  * @template TGlobalState - The type of the state of the custom reducer.
  * @template TAction - The type of the actions of the custom reducer.
@@ -722,7 +826,6 @@ declare function baseReducer<TState extends PHBaseState = PHBaseState>(document:
  *   - `SET_NAME`
  *   - `UNDO`
  *   - `REDO`
- *   - `PRUNE`
  *
  * It also updates the document-related attributes on every operation.
  *
@@ -732,7 +835,6 @@ declare function baseReducer<TState extends PHBaseState = PHBaseState>(document:
  * @returns The new reducer.
  */
 declare function createReducer<TState extends PHBaseState = PHBaseState>(stateReducer: StateReducer<TState>, documentReducer?: typeof baseReducer): Reducer<TState>;
-declare function pruneOperation<TState extends PHBaseState = PHBaseState>(document: PHDocument<TState>, input: PruneActionInput, wrappedReducer: StateReducer<TState>): PHDocument<TState>;
 //#endregion
 //#region document-model/reducers.d.ts
 declare const documentModelHeaderReducer: DocumentModelHeaderOperations;
@@ -750,7 +852,7 @@ declare const documentModelReducer: Reducer<DocumentModelPHState>;
  * Reserved operation names from base reducer (core/actions.ts).
  * These names cannot be used for custom operations.
  */
-declare const RESERVED_OPERATION_NAMES: readonly ["UNDO", "REDO", "PRUNE", "LOAD_STATE", "SET_NAME", "SET_PREFERRED_EDITOR", "NOOP"];
+declare const RESERVED_OPERATION_NAMES: readonly ["UNDO", "REDO", "SET_NAME", "SET_PREFERRED_EDITOR", "NOOP"];
 type ReservedOperationName = (typeof RESERVED_OPERATION_NAMES)[number];
 /**
  * Operation names become the literal action `type` string at runtime and the
@@ -832,5 +934,6 @@ declare function assertOperationErrorIdUnique(state: DocumentModelGlobalState, i
 declare function assertOperationExampleIdUnique(state: DocumentModelGlobalState, id: string): void;
 declare function validateOperations(operations: DocumentOperations): ValidationError[];
 //#endregion
-export { getFileBrowser as $, mentionedGroupIds as $n, documentModelInitialLocalState as $t, documentModelVersioningReducer as A, InitializeAuthActionInputSchema as An, isDocumentModelDocument as At, createVerificationSigner as B, SetGrantActionInputSchema as Bn, buildOperationSignatureMessage as Bt, documentModelModuleReducer as C, AuthRefusal as Cn, BaseDocumentHeaderSchema as Ct, documentModelReducer as D, ConditionContext as Dn, DocumentModelSchema as Dt, documentModelOperationReducer as E, AuthVerb as En, DocumentModelPHStateSchema as Et, replayOperations as F, RemoveGrantAction as Fn, DOCUMENT_DELETED_REASON as Ft, baseLoadFromInput as G, applySetGrantAction as Gn, HASH_ALGORITHM_SHA1 as Gt, validateHeader as H, applyInitializeAuthAction as Hn, getUnixTimestamp as Ht, updateDocument as I, RemoveGrantActionInput as In, isDenied as It, createMinimalZip as J, decide as Jn, HASH_ENCODING_BASE64 as Jt, baseLoadFromInputVersioned as K, assertAuthPreservedOnDuplicate as Kn, HASH_ALGORITHM_SHA256 as Kt, createPresignedHeader as L, RemoveGrantActionInputSchema as Ln, ab2hex as Lt, createReducer as M, MoveGrantAction as Mn, AUTH_DENIED_BY_GRANT_REASON as Mt, processUndoRedo as N, MoveGrantActionInput as Nn, AUTH_NO_GRANT_REASON as Nt, documentModelStateReducer as O, InitializeAuthAction as On, assertIsDocumentModelDocument as Ot, pruneOperation as P, MoveGrantActionInputSchema as Pn, AUTH_VERSION_UNSUPPORTED_REASON as Pt, fetchFileBrowser as Q, isDocumentCreator as Qn, documentModelInitialGlobalState as Qt, createSignedHeader as R, SetGrantAction as Rn, base58Decode as Rt, documentModelHeaderReducer as S, AuthEvaluation as Sn, groupMembershipActionTypes as St, documentModelOperationExampleReducer as T, AuthSubject as Tn, DocumentModelHeaderSchema as Tt, verify as U, applyMoveGrantAction as Un, hashBrowser as Ut, sign as V, applyAuthAction as Vn, buildOperationSignatureParams as Vt, BulkArchiveEntry as W, applyRemoveGrantAction as Wn, hex2ab as Wt, documentModelLoadFromInput as X, initializeAuth as Xn, documentModelFileExtension as Xt, createZip as Y, evaluate as Yn, HASH_ENCODING_HEX as Yt, documentModelSaveToFileHandle as Z, isAuthAction as Zn, documentModelGlobalState as Zt, validateModuleOperation as _, isPlainValue as _n, InvalidActionInputZodError as _t, assertOperationErrorIdUnique as a, MAX_AUTH_GRANTS as an, TransportActionContext as ar, VersionedReducers as at, validateOperations as b, AuthAction as bn, documentModelDocumentType as bt, findModuleOrThrow as c, MAX_CONDITION_NODES as cn, AuthActionNotAllowedError as ct, findOperationOrThrow as d, assertValidGrantUpsert as dn, AuthPolicyNotPreservedError as dt, AuthAdministrationLockoutError as en, moveGrant as er, isDocumentZip as et, getAllOperationNames as f, assertValidInitialGrants as fn, DowngradeNotSupportedError as ft, validateModule as g, grantProblem as gn, InvalidActionInputError as gt, validateInitialState as h, evaluateGrants as hn, HashMismatchError as ht, assertModuleIdUnique as i, InvalidGrantError as in, TransportAction as ir, zipEntries as it, baseReducer as j, MAX_SUPPORTED_AUTH_VERSION as jn, isDocumentModelState as jt, documentModelStateSchemaReducer as k, InitializeAuthActionInput as kn, assertIsDocumentModelState as kt, findOperationErrorOrThrow as l, assertAuthAdministrationRetained as ln, AuthAlreadyInitializedError as lt, isValidOperationNameFormat as m, evaluateGrantStack as mn, GrantNotFoundError as mt, RESERVED_OPERATION_NAMES as n, GrantSchema as nn, resolveSnapshotAuth as nr, readFileBrowser as nt, assertOperationExampleIdUnique as o, MAX_CAPABILITY_OPERATIONS as on, TransportSigner as or, VersionedReplayConfig as ot, isReservedOperationName as p, evaluateCondition as pn, FileSystemError as pt, baseSaveToFileHandle as q, assertAuthScopeActionAllowed as qn, HASH_ALGORITHM_SHA512 as qt, ReservedOperationName as r, GroupPrincipalNotAllowedError as rn, setGrant as rr, writeFileBrowser as rt, assertOperationIdUnique as s, MAX_CONDITION_DEPTH as sn, toTransportAction as sr, replayDocumentVersioned as st, OPERATION_NAME_PATTERN as t, AuthAdministrationMissingError as tn, removeGrant as tr, parseBulkArchive as tt, findOperationExampleOrThrow as u, assertValidGrant as un, AuthInitializerNotCreatorError as ut, validateModules as v, referencedGroupIds as vn, InvalidAuthVersionError as vt, documentModelOperationErrorReducer as w, AuthRequest as wn, BaseDocumentStateSchema as wt, validateStateSchemaName as x, AuthDecision as xn, groupDocumentType as xt, validateOperationName as y, AUTH_ACTION_TYPES as yn, UnsupportedDocumentModelVersionError as yt, createSignedHeaderForSigner as z, SetGrantActionInput as zn, base64UrlToBytes as zt };
-//# sourceMappingURL=index-DP3QgHTq.d.ts.map
+export { peerSupports as $, MAX_SUPPORTED_AUTH_VERSION as $n, AUTH_DENIED_BY_GRANT_REASON as $t, documentModelVersioningReducer as A, MAX_CONDITION_NODES as An, AuthAlreadyInitializedError as At, PeerCapability as B, referencedGroupIds as Bn, UnsupportedDocumentModelVersionError as Bt, documentModelModuleReducer as C, AuthAdministrationMissingError as Cn, removeGrant as Cr, readFileBrowser as Ct, documentModelReducer as D, MAX_AUTH_GRANTS as Dn, TransportActionContext as Dr, VersionedReplayConfig as Dt, documentModelOperationReducer as E, InvalidGrantError as En, TransportAction as Er, VersionedReducers as Et, updateDocument as F, evaluateCondition as Fn, GrantNotFoundError as Ft, coversLocal as G, AuthRefusal as Gn, BaseDocumentStateSchema as Gt, PeerManifest as H, AuthAction as Hn, groupDocumentType as Ht, FeatureCapability as I, evaluateGrantStack as In, HashMismatchError as It, legacySupports as J, AuthVerb as Jn, DocumentModelSchema as Jt, holdReason as K, AuthRequest as Kn, DocumentModelHeaderSchema as Kt, HoldReason as L, evaluateGrants as Ln, InvalidActionInputError as Lt, createReducer as M, assertValidGrant as Mn, AuthPolicyNotPreservedError as Mt, processUndoRedo as N, assertValidGrantUpsert as Nn, DowngradeNotSupportedError as Nt, documentModelStateReducer as O, MAX_CAPABILITY_OPERATIONS as On, TransportSigner as Or, replayDocumentVersioned as Ot, replayOperations as P, assertValidInitialGrants as Pn, FileSystemError as Pt, mergePeerCapabilities as Q, InitializeAuthActionInputSchema as Qn, isDocumentModelState as Qt, PEER_CAPABILITIES as R, grantProblem as Rn, InvalidActionInputZodError as Rt, documentModelHeaderReducer as S, AuthAdministrationLockoutError as Sn, moveGrant as Sr, parseBulkArchive as St, documentModelOperationExampleReducer as T, GroupPrincipalNotAllowedError as Tn, setGrant as Tr, zipEntries as Tt, ProtocolCapability as U, AuthDecision as Un, groupMembershipActionTypes as Ut, PeerCapabilityFlags as V, AUTH_ACTION_TYPES as Vn, documentModelDocumentType as Vt, Supports as W, AuthEvaluation as Wn, BaseDocumentHeaderSchema as Wt, localSupports as X, InitializeAuthAction as Xn, assertIsDocumentModelState as Xt, localPeerManifest as Y, ConditionContext as Yn, assertIsDocumentModelDocument as Yt, manifestRevision as Z, InitializeAuthActionInput as Zn, isDocumentModelDocument as Zt, validateModuleOperation as _, HASH_ENCODING_HEX as _n, evaluate as _r, documentModelLoadFromInput as _t, assertOperationErrorIdUnique as a, base58Decode as an, RemoveGrantActionInputSchema as ar, createSignedHeaderForSigner as at, validateOperations as b, documentModelInitialGlobalState as bn, isDocumentCreator as br, getFileBrowser as bt, findModuleOrThrow as c, buildOperationSignatureParams as cn, SetGrantActionInputSchema as cr, sign as ct, findOperationOrThrow as d, hashBrowser as dn, applyMoveGrantAction as dr, BulkArchiveEntry as dt, AUTH_NO_GRANT_REASON as en, MoveGrantAction as er, readPeerManifest as et, getAllOperationNames as f, hex2ab as fn, applyRemoveGrantAction as fr, baseLoadFromInput as ft, validateModule as g, HASH_ENCODING_BASE64 as gn, decide as gr, createZip as gt, validateInitialState as h, HASH_ALGORITHM_SHA512 as hn, assertAuthScopeActionAllowed as hr, createMinimalZip as ht, assertModuleIdUnique as i, ab2hex as in, RemoveGrantActionInput as ir, createSignedHeader as it, baseReducer as j, assertAuthAdministrationRetained as jn, AuthInitializerNotCreatorError as jt, documentModelStateSchemaReducer as k, MAX_CONDITION_DEPTH as kn, toTransportAction as kr, AuthActionNotAllowedError as kt, findOperationErrorOrThrow as l, bytesToBase64Url as ln, applyAuthAction as lr, validateHeader as lt, isValidOperationNameFormat as m, HASH_ALGORITHM_SHA256 as mn, assertAuthPreservedOnDuplicate as mr, baseSaveToFileHandle as mt, RESERVED_OPERATION_NAMES as n, DOCUMENT_DELETED_REASON as nn, MoveGrantActionInputSchema as nr, createCopyHeader as nt, assertOperationExampleIdUnique as o, base64UrlToBytes as on, SetGrantAction as or, createVerificationSigner as ot, isReservedOperationName as p, HASH_ALGORITHM_SHA1 as pn, applySetGrantAction as pr, baseLoadFromInputVersioned as pt, isOlderManifest as q, AuthSubject as qn, DocumentModelPHStateSchema as qt, ReservedOperationName as r, isDenied as rn, RemoveGrantAction as rr, createPresignedHeader as rt, assertOperationIdUnique as s, buildOperationSignatureMessage as sn, SetGrantActionInput as sr, hasDerivedDocumentId as st, OPERATION_NAME_PATTERN as t, AUTH_VERSION_UNSUPPORTED_REASON as tn, MoveGrantActionInput as tr, selectProtocolVersions as tt, findOperationExampleOrThrow as u, getUnixTimestamp as un, applyInitializeAuthAction as ur, verify as ut, validateModules as v, documentModelFileExtension as vn, initializeAuth as vr, documentModelSaveToFileHandle as vt, documentModelOperationErrorReducer as w, GrantSchema as wn, resolveSnapshotAuth as wr, writeFileBrowser as wt, validateStateSchemaName as x, documentModelInitialLocalState as xn, mentionedGroupIds as xr, isDocumentZip as xt, validateOperationName as y, documentModelGlobalState as yn, isAuthAction as yr, fetchFileBrowser as yt, PEER_MANIFEST_FORMAT as z, isPlainValue as zn, InvalidAuthVersionError as zt };
+export {};
+//# sourceMappingURL=index-D6833Siv.d.ts.map

package/dist/index-D6833Siv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D6833Siv.d.ts","names":[],"sources":["../document-model/action-transport.ts","../document-model/auth.ts","../document-model/auth-v1.ts","../document-model/constants.ts","../document-model/crypto.ts","../document-model/denied.ts","../document-model/document-schema.ts","../document-model/document-type.ts","../document-model/errors.ts","../document-model/versioned-replay.ts","../document-model/files.ts","../document-model/header.ts","../document-model/peer-agreement.ts","../document-model/reducer.ts","../document-model/reducers.ts","../document-model/validation.ts"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { a as AnalyticsSeriesInput, c as CompoundAnalyticsExpression, d as ConversionMetric, f as IAnalyticsStore, i as AnalyticsSeries, l as CompoundAnalyticsInputs, n as AnalyticsOperand, o as AnalyticsSeriesQuery, p as MultiCurrencyConversion, r as AnalyticsQuery, s as AnalyticsUpdateCallback, t as AnalyticsDimension, u as CompoundAnalyticsQuery } from "./types-C1in4fl3.js";
-import { $ as AddOperationExampleAction, $i as SetOperationErrorCodeAction, $n as MutationDeleteOperationErrorArgs, $r as RedoActionInput, $s as ProcessorDispatchResult, $t as DocumentModelOperationExampleOperations, A as PHReactorRenown, Aa as SigningParameters, Ai as SetAuthorNameAction, An as LoadStateActionInput, Ar as MutationSetOperationTemplateArgs, At as DeleteOperationErrorInput, Ba as UpdateChangeLogItemAction, Bi as SetModelIdAction, Bn as ModuleSpecification, Br as OperationsByScope, Bt as DocumentModelGlobalState, C as PHConnectReactor, Ca as Set_PreferredEditor, Ci as SchemaNOOPAction, Cn as Incremental, Cr as MutationSetOperationErrorCodeArgs, Ct as DeleteChildDocumentSignal, D as PHConnectRuntimeConfig, Da as SignalResults, Di as SchemaSetPreferredEditorAction, Dn as LoadFromFile, Dr as MutationSetOperationNameArgs, Dt as DeleteModuleInput, E as PHConnectRenownAdapters, Ea as SignalResult, Ei as SchemaSetNameAction, En as IsStateOfType, Er as MutationSetOperationErrorTemplateArgs, Et as DeleteModuleAction, F as PathValidation, Fa as SubgraphModule, Fi as SetInitialStateInput, Fn as MakeOptional, Fr as MutationUpdateStateExampleArgs, Ft as DeleteStateExampleInput, G as Actions, Ga as UpdateRelationshipActionInput, Gi as SetModuleDescriptionInput, Gn as MutationAddModuleArgs, Gr as PowerhouseModule, Gt as DocumentModelLocalState, H as ActionSignatureContext, Ha as UpdateOperationExampleAction, Hi as SetModelNameAction, Hn as MoveOperationInput, Hr as PartialState, Ht as DocumentModelHeaderOperations, I as PowerhouseConfig, Ia as Undo, Ii as SetModelDescriptionAction, In as Manifest, Ir as NOOPAction, It as DocumentAction, J as AddModuleAction, Ja as UpgradeDocumentAction, Ji as SetNameAction, Jn as MutationAddOperationExampleArgs, Jr as PruneActionInput, Js as IProcessorDispatch, Jt as DocumentModelModuleOperations, K as AddChangeLogItemAction, Ka as UpdateStateExampleAction, Ki as SetModuleNameAction, Kn as MutationAddOperationArgs, Kr as Prune, Kt as DocumentModelModule, L as PowerhousePackage, La as UndoAction, Li as SetModelDescriptionInput, Ln as MappedOperation, Lr as OperationErrorSpecification, Lt as DocumentModelAction, M as PHRenownRainbowAdapterConfig, Ma as SkipHeaderOperations, Mi as SetAuthorWebsiteAction, Mn as Load_State, Mr as MutationUndoArgs, Mt as DeleteOperationExampleInput, N as PackageManagerArgs, Na as State, Ni as SetAuthorWebsiteInput, Nn as MakeEmpty, Nr as MutationUpdateChangeLogItemInputArgs, Nt as DeleteOperationInput, O as PHConnectSentry, Oa as SignalType, Oi as SchemaUndoAction, On as LoadFromInput, Or as MutationSetOperationReducerArgs, Ot as DeleteOperationAction, P as ParsedCmdResult, Pa as StateReducer, Pi as SetInitialStateAction, Pn as MakeMaybe, Pr as MutationUpdateOperationExampleArgs, Pt as DeleteStateExampleAction, Q as AddOperationErrorInput, Qi as SetOperationDescriptionInput, Qn as MutationDeleteOperationArgs, Qr as RedoAction, Qs as ProcessorApps, Qt as DocumentModelOperationExampleAction, R as ServiceAction, Ra as UndoActionInput, Ri as SetModelExtensionAction, Rn as Maybe, Rr as OperationIndex, Rt as DocumentModelDocument, S as PHConnectPwaUrlPattern, Sa as Set_Name, Si as SchemaLoadStateAction, Sn as ISigner, Sr as MutationSetOperationDescriptionArgs, St as DeleteChildDocumentInput, T as PHConnectRenown, Ta as SignalDispatch, Ti as SchemaRedoAction, Tn as IsDocumentOfType, Tr as MutationSetOperationErrorNameArgs, Tt as DeleteDocumentActionInput, U as ActionSigningHandler, Ua as UpdateOperationExampleInput, Ui as SetModelNameInput, Un as Mutation, Ur as PhAiToolAnnotations, Ut as DocumentModelInput, V as ActionErrorCallback, Va as UpdateChangeLogItemInput, Vi as SetModelIdInput, Vn as MoveOperationAction, Vr as PartialRecord, Vt as DocumentModelHeaderAction, W as ActionVerificationHandler, Wa as UpdateRelationshipAction, Wi as SetModuleDescriptionAction, Wn as MutationAddChangeLogItemInputArgs, Wr as PhAiToolDescriptor, Wt as DocumentModelLib, X as AddOperationAction, Xa as User, Xi as SetNameOperation, Xn as MutationDeleteChangeLogItemInputArgs, Xr as Query, Xs as IProcessorManager, Xt as DocumentModelOperationErrorAction, Y as AddModuleInput, Ya as UpgradeDocumentActionInput, Yi as SetNameActionInput, Yn as MutationAddStateExampleArgs, Yr as Publisher, Ys as IProcessorHostModuleBase, Yt as DocumentModelOperationAction, Z as AddOperationErrorAction, Za as ValidationError, Zi as SetOperationDescriptionAction, Zn as MutationDeleteModuleArgs, Zr as Redo, Zs as ProcessorApp, Zt as DocumentModelOperationErrorOperations, _ as PHConnectPwaCacheStrategy, _a as SetPreferredEditorAction, _i as ReplayDocumentOptions, _n as ID, _r as MutationSetModelIdArgs, _t as CreateDocumentAction, a as PHConnectAi, aa as SetOperationErrorTemplateAction, ac as TrackedProcessor, ai as ReorderChangeLogItemsAction, an as DocumentModelVersioningAction, ar as MutationRedoArgs, at as AddStateExampleInput, b as PHConnectPwaManifest, ba as SetStateSchemaAction, bi as SaveToFileHandle, bn as ISignal, br as MutationSetModuleNameArgs, bt as DeleteChangeLogItemAction, c as PHConnectDefaultDrive, ca as SetOperationNameInput, ci as ReorderModuleOperationsInput, cn as DocumentSpecification, cr as MutationReorderModulesArgs, ct as Author, d as PHConnectDriveSection, da as SetOperationSchemaAction, di as ReorderOperationErrorsAction, dn as EditorModule, dr as MutationReorderStateExamplesArgs, dt as ConfigEntryType, ea as SetOperationErrorCodeInput, ec as ProcessorFactory, ei as Reducer, en as DocumentModelOperationOperations, er as MutationDeleteOperationExampleArgs, et as AddOperationExampleInput, f as PHConnectDriveSections, fa as SetOperationSchemaInput, fi as ReorderOperationErrorsInput, fn as EditorProps, fr as MutationSetAuthorNameArgs, ft as CopyChildDocumentInput, g as PHConnectPwa, ga as SetOperationTemplateInput, gi as ReorderStateExamplesInput, gn as IAction, gr as MutationSetModelExtensionArgs, gt as CreateDocument, h as PHConnectPackages, ha as SetOperationTemplateAction, hi as ReorderStateExamplesAction, hn as GetDocumentOptions, hr as MutationSetModelDescriptionArgs, ht as CreateChildDocumentSignal, i as LogLevels, ia as SetOperationErrorNameInput, ic as ProcessorStatus, ii as RemoveRelationshipActionInput, in as DocumentModelUtils, ir as MutationPruneArgs, it as AddStateExampleAction, j as PHRenownPrivyAdapterConfig, ja as SkipHeaderOperationIndex, ji as SetAuthorNameInput, jn as LoadStateActionStateInput, jr as MutationSetStateSchemaArgs, jt as DeleteOperationExampleAction, k as PHPackageProvider, ka as SignatureVerificationHandler, ki as ScopeState, kn as LoadStateAction, kr as MutationSetOperationSchemaArgs, kt as DeleteOperationErrorAction, l as PHConnectDefaultDriveLocal, la as SetOperationReducerAction, li as ReorderModulesAction, ln as ENSInfo, lr as MutationReorderOperationErrorsArgs, lt as CodeExample, m as PHConnectInstance, ma as SetOperationScopeInput, mi as ReorderOperationExamplesInput, mn as FileInput, mr as MutationSetInitialStateArgs, mt as CreateChildDocumentInput, n as DrivePreserveStrategy, na as SetOperationErrorDescriptionInput, nc as ProcessorFilter, ni as ReleaseNewVersionAction, nn as DocumentModelStateAction, nr as MutationLoadStateArgs, nt as AddRelationshipAction, o as PHConnectApp, oa as SetOperationErrorTemplateInput, oi as ReorderChangeLogItemsInput, on as DocumentModelVersioningOperations, or as MutationReorderChangeLogItemsInputArgs, ot as AssertIsDocumentOfType, p as PHConnectDrives, pa as SetOperationScopeAction, pi as ReorderOperationExamplesAction, pn as Exact, pr as MutationSetAuthorWebsiteArgs, pt as CopyChildDocumentSignal, q as AddChangeLogItemInput, qa as UpdateStateExampleInput, qi as SetModuleNameInput, qn as MutationAddOperationErrorArgs, qr as PruneAction, qs as IProcessor, qt as DocumentModelModuleAction, r as LogLevel, ra as SetOperationErrorNameAction, rc as ProcessorRecord, ri as RemoveRelationshipAction, rn as DocumentModelStateOperations, rr as MutationMoveOperationArgs, rt as AddRelationshipActionInput, s as PHConnectBranding, sa as SetOperationNameAction, si as ReorderModuleOperationsAction, sn as DocumentOperationsIgnoreMap, sr as MutationReorderModuleOperationsArgs, st as AssertIsStateOfType, t as DrivePreserveStrategies, ta as SetOperationErrorDescriptionAction, tc as ProcessorFactoryBuilder, ti as ReducerOptions, tn as DocumentModelPHState, tr as MutationDeleteStateExampleArgs, tt as AddOperationInput, u as PHConnectDefaultDriveRemote, ua as SetOperationReducerInput, ui as ReorderModulesInput, un as EditorDispatch, ur as MutationReorderOperationExamplesArgs, ut as ConfigEntry, v as PHConnectPwaFileHandler, va as SetPreferredEditorActionInput, vi as RevisionsFilter, vn as IDocument, vr as MutationSetModelNameArgs, vt as CreateDocumentActionInput, w as PHConnectReactorFeatureFlags, wa as Signal, wi as SchemaPruneAction, wn as InputMaybe, wr as MutationSetOperationErrorDescriptionArgs, wt as DeleteDocumentAction, x as PHConnectPwaRuntimeCaching, xa as SetStateSchemaInput, xi as Scalars, xn as ISignalResult, xr as MutationSetNameArgs, xt as DeleteChangeLogItemInput, y as PHConnectPwaIcon, ya as SetPreferredEditorOperation, yi as SaveToFile, yn as IOperation, yr as MutationSetModuleDescriptionArgs, yt as CreateState, z as ServiceActions, za as UndoRedoAction, zi as SetModelExtensionInput, zn as MinimalBackupData, zr as OperationSpecification, zt as DocumentModelDocumentModelModule } from "./types-BIoOWpOT.js";
-import { i as PACKAGES_DEPENDENCIES, n as APPS_DEPENDENCIES, r as CLIS_DEPENDENCIES, t as ALL_POWERHOUSE_DEPENDENCIES } from "./constants-BP_gjn8g.js";
-import { $ as LegacySynchronizationUnit, A as TriggerData, B as RegistryPackageMap, C as RemoveTriggerInput, D as SetSharingTypeInput, E as SetDriveNameInput, F as PackageInfo, G as DriveInput, H as RegistryPackageStatus, I as PackageListItem, J as SharingType, K as GenerateNodesCopyIdGenerator, L as PackagePage, M as TriggerType, N as UpdateFileInput, O as TransmitterType, P as UpdateNodeInput, Q as LegacyAddFileInput, R as RegistryPackage, S as RemoveListenerInput, T as SetDriveIconInput, U as DocumentDrivePHState, V as RegistryPackageSource, W as DriveDocumentModelModule, X as DocumentDriveDocument, Y as DocumentDriveAction, Z as LegacyAddFileAction, _ as ListenerInput, _t as SetDriveNameAction, a as CopyNodeInput, at as DocumentDriveNodeOperations, b as PullResponderTriggerData, c as DocumentDriveLocalState, ct as UpdateNodeAction, d as FolderNode, dt as DocumentDriveDriveAction, et as AddFileAction, f as Listener, ft as DocumentDriveDriveOperations, g as ListenerFilterInput, gt as SetDriveIconAction, h as ListenerFilter, ht as SetAvailableOfflineAction, i as AddTriggerInput, it as DocumentDriveNodeAction, j as TriggerInput, k as Trigger, lt as AddListenerAction, m as ListenerCallInfoInput, mt as RemoveTriggerAction, n as AddFolderInput, nt as CopyNodeAction, o as DeleteNodeInput, ot as MoveNodeAction, p as ListenerCallInfo, pt as RemoveListenerAction, q as GenerateNodesCopySrc, r as AddListenerInput, rt as DeleteNodeAction, s as DocumentDriveGlobalState, st as UpdateFileAction, t as AddFileInput, tt as AddFolderAction, u as FileNode, ut as AddTriggerAction, v as MoveNodeInput, vt as SetSharingTypeAction, w as SetAvailableOfflineInput, x as PullResponderTriggerDataInput, y as Node, z as RegistryPackageList } from "./types-DDpRvBK_.js";
-import { n as buildTreeUrl, r as shortGitSha, t as GITHUB_REPO_URL } from "./index-C_iVZe7f.js";
-export { ALL_POWERHOUSE_DEPENDENCIES, APPS_DEPENDENCIES, ActionErrorCallback, ActionSignatureContext, ActionSigningHandler, ActionVerificationHandler, Actions, AddChangeLogItemAction, AddChangeLogItemInput, AddFileAction, AddFileInput, AddFolderAction, AddFolderInput, AddListenerAction, AddListenerInput, AddModuleAction, AddModuleInput, AddOperationAction, AddOperationErrorAction, AddOperationErrorInput, AddOperationExampleAction, AddOperationExampleInput, AddOperationInput, AddRelationshipAction, AddRelationshipActionInput, AddStateExampleAction, AddStateExampleInput, AddTriggerAction, AddTriggerInput, AnalyticsDimension, AnalyticsOperand, AnalyticsQuery, AnalyticsSeries, AnalyticsSeriesInput, AnalyticsSeriesQuery, AnalyticsUpdateCallback, AssertIsDocumentOfType, AssertIsStateOfType, Author, CLIS_DEPENDENCIES, CodeExample, CompoundAnalyticsExpression, CompoundAnalyticsInputs, CompoundAnalyticsQuery, ConfigEntry, ConfigEntryType, ConversionMetric, CopyChildDocumentInput, CopyChildDocumentSignal, CopyNodeAction, CopyNodeInput, CreateChildDocumentInput, CreateChildDocumentSignal, CreateDocument, CreateDocumentAction, CreateDocumentActionInput, CreateState, DeleteChangeLogItemAction, DeleteChangeLogItemInput, DeleteChildDocumentInput, DeleteChildDocumentSignal, DeleteDocumentAction, DeleteDocumentActionInput, DeleteModuleAction, DeleteModuleInput, DeleteNodeAction, DeleteNodeInput, DeleteOperationAction, DeleteOperationErrorAction, DeleteOperationErrorInput, DeleteOperationExampleAction, DeleteOperationExampleInput, DeleteOperationInput, DeleteStateExampleAction, DeleteStateExampleInput, DocumentAction, DocumentDriveAction, DocumentDriveDocument, DocumentDriveDriveAction, DocumentDriveDriveOperations, DocumentDriveGlobalState, DocumentDriveLocalState, DocumentDriveNodeAction, DocumentDriveNodeOperations, DocumentDrivePHState, DocumentModelAction, DocumentModelDocument, DocumentModelDocumentModelModule, DocumentModelGlobalState, DocumentModelHeaderAction, DocumentModelHeaderOperations, DocumentModelInput, DocumentModelLib, DocumentModelLocalState, DocumentModelModule, DocumentModelModuleAction, DocumentModelModuleOperations, DocumentModelOperationAction, DocumentModelOperationErrorAction, DocumentModelOperationErrorOperations, DocumentModelOperationExampleAction, DocumentModelOperationExampleOperations, DocumentModelOperationOperations, DocumentModelPHState, DocumentModelStateAction, DocumentModelStateOperations, DocumentModelUtils, DocumentModelVersioningAction, DocumentModelVersioningOperations, DocumentOperationsIgnoreMap, DocumentSpecification, DriveDocumentModelModule, DriveInput, DrivePreserveStrategies, DrivePreserveStrategy, ENSInfo, EditorDispatch, EditorModule, EditorProps, Exact, FileInput, FileNode, FolderNode, GITHUB_REPO_URL, GenerateNodesCopyIdGenerator, GenerateNodesCopySrc, GetDocumentOptions, IAction, IAnalyticsStore, ID, IDocument, IOperation, IProcessor, IProcessorDispatch, IProcessorHostModuleBase, IProcessorManager, ISignal, ISignalResult, ISigner, Incremental, InputMaybe, IsDocumentOfType, IsStateOfType, LegacyAddFileAction, LegacyAddFileInput, LegacySynchronizationUnit, Listener, ListenerCallInfo, ListenerCallInfoInput, ListenerFilter, ListenerFilterInput, ListenerInput, LoadFromFile, LoadFromInput, LoadStateAction, LoadStateActionInput, LoadStateActionStateInput, Load_State, LogLevel, LogLevels, MakeEmpty, MakeMaybe, MakeOptional, Manifest, MappedOperation, Maybe, MinimalBackupData, ModuleSpecification, MoveNodeAction, MoveNodeInput, MoveOperationAction, MoveOperationInput, MultiCurrencyConversion, Mutation, MutationAddChangeLogItemInputArgs, MutationAddModuleArgs, MutationAddOperationArgs, MutationAddOperationErrorArgs, MutationAddOperationExampleArgs, MutationAddStateExampleArgs, MutationDeleteChangeLogItemInputArgs, MutationDeleteModuleArgs, MutationDeleteOperationArgs, MutationDeleteOperationErrorArgs, MutationDeleteOperationExampleArgs, MutationDeleteStateExampleArgs, MutationLoadStateArgs, MutationMoveOperationArgs, MutationPruneArgs, MutationRedoArgs, MutationReorderChangeLogItemsInputArgs, MutationReorderModuleOperationsArgs, MutationReorderModulesArgs, MutationReorderOperationErrorsArgs, MutationReorderOperationExamplesArgs, MutationReorderStateExamplesArgs, MutationSetAuthorNameArgs, MutationSetAuthorWebsiteArgs, MutationSetInitialStateArgs, MutationSetModelDescriptionArgs, MutationSetModelExtensionArgs, MutationSetModelIdArgs, MutationSetModelNameArgs, MutationSetModuleDescriptionArgs, MutationSetModuleNameArgs, MutationSetNameArgs, MutationSetOperationDescriptionArgs, MutationSetOperationErrorCodeArgs, MutationSetOperationErrorDescriptionArgs, MutationSetOperationErrorNameArgs, MutationSetOperationErrorTemplateArgs, MutationSetOperationNameArgs, MutationSetOperationReducerArgs, MutationSetOperationSchemaArgs, MutationSetOperationTemplateArgs, MutationSetStateSchemaArgs, MutationUndoArgs, MutationUpdateChangeLogItemInputArgs, MutationUpdateOperationExampleArgs, MutationUpdateStateExampleArgs, NOOPAction, Node, OperationErrorSpecification, OperationIndex, OperationSpecification, OperationsByScope, PACKAGES_DEPENDENCIES, PHConnectAi, PHConnectApp, PHConnectBranding, PHConnectDefaultDrive, PHConnectDefaultDriveLocal, PHConnectDefaultDriveRemote, PHConnectDriveSection, PHConnectDriveSections, PHConnectDrives, PHConnectInstance, PHConnectPackages, PHConnectPwa, PHConnectPwaCacheStrategy, PHConnectPwaFileHandler, PHConnectPwaIcon, PHConnectPwaManifest, PHConnectPwaRuntimeCaching, PHConnectPwaUrlPattern, PHConnectReactor, PHConnectReactorFeatureFlags, PHConnectRenown, PHConnectRenownAdapters, PHConnectRuntimeConfig, PHConnectSentry, PHPackageProvider, PHReactorRenown, PHRenownPrivyAdapterConfig, PHRenownRainbowAdapterConfig, PackageInfo, PackageListItem, PackageManagerArgs, PackagePage, ParsedCmdResult, PartialRecord, PartialState, PathValidation, PhAiToolAnnotations, PhAiToolDescriptor, PowerhouseConfig, PowerhouseModule, PowerhousePackage, ProcessorApp, ProcessorApps, ProcessorDispatchResult, ProcessorFactory, ProcessorFactoryBuilder, ProcessorFilter, ProcessorRecord, ProcessorStatus, Prune, PruneAction, PruneActionInput, Publisher, PullResponderTriggerData, PullResponderTriggerDataInput, Query, Redo, RedoAction, RedoActionInput, Reducer, ReducerOptions, RegistryPackage, RegistryPackageList, RegistryPackageMap, RegistryPackageSource, RegistryPackageStatus, ReleaseNewVersionAction, RemoveListenerAction, RemoveListenerInput, RemoveRelationshipAction, RemoveRelationshipActionInput, RemoveTriggerAction, RemoveTriggerInput, ReorderChangeLogItemsAction, ReorderChangeLogItemsInput, ReorderModuleOperationsAction, ReorderModuleOperationsInput, ReorderModulesAction, ReorderModulesInput, ReorderOperationErrorsAction, ReorderOperationErrorsInput, ReorderOperationExamplesAction, ReorderOperationExamplesInput, ReorderStateExamplesAction, ReorderStateExamplesInput, ReplayDocumentOptions, RevisionsFilter, SaveToFile, SaveToFileHandle, Scalars, SchemaLoadStateAction, SchemaNOOPAction, SchemaPruneAction, SchemaRedoAction, SchemaSetNameAction, SchemaSetPreferredEditorAction, SchemaUndoAction, ScopeState, ServiceAction, ServiceActions, SetAuthorNameAction, SetAuthorNameInput, SetAuthorWebsiteAction, SetAuthorWebsiteInput, SetAvailableOfflineAction, SetAvailableOfflineInput, SetDriveIconAction, SetDriveIconInput, SetDriveNameAction, SetDriveNameInput, SetInitialStateAction, SetInitialStateInput, SetModelDescriptionAction, SetModelDescriptionInput, SetModelExtensionAction, SetModelExtensionInput, SetModelIdAction, SetModelIdInput, SetModelNameAction, SetModelNameInput, SetModuleDescriptionAction, SetModuleDescriptionInput, SetModuleNameAction, SetModuleNameInput, SetNameAction, SetNameActionInput, SetNameOperation, SetOperationDescriptionAction, SetOperationDescriptionInput, SetOperationErrorCodeAction, SetOperationErrorCodeInput, SetOperationErrorDescriptionAction, SetOperationErrorDescriptionInput, SetOperationErrorNameAction, SetOperationErrorNameInput, SetOperationErrorTemplateAction, SetOperationErrorTemplateInput, SetOperationNameAction, SetOperationNameInput, SetOperationReducerAction, SetOperationReducerInput, SetOperationSchemaAction, SetOperationSchemaInput, SetOperationScopeAction, SetOperationScopeInput, SetOperationTemplateAction, SetOperationTemplateInput, SetPreferredEditorAction, SetPreferredEditorActionInput, SetPreferredEditorOperation, SetSharingTypeAction, SetSharingTypeInput, SetStateSchemaAction, SetStateSchemaInput, Set_Name, Set_PreferredEditor, SharingType, Signal, SignalDispatch, SignalResult, SignalResults, SignalType, SignatureVerificationHandler, SigningParameters, SkipHeaderOperationIndex, SkipHeaderOperations, State, StateReducer, SubgraphModule, TrackedProcessor, TransmitterType, Trigger, TriggerData, TriggerInput, TriggerType, Undo, UndoAction, UndoActionInput, UndoRedoAction, UpdateChangeLogItemAction, UpdateChangeLogItemInput, UpdateFileAction, UpdateFileInput, UpdateNodeAction, UpdateNodeInput, UpdateOperationExampleAction, UpdateOperationExampleInput, UpdateRelationshipAction, UpdateRelationshipActionInput, UpdateStateExampleAction, UpdateStateExampleInput, UpgradeDocumentAction, UpgradeDocumentActionInput, User, ValidationError, buildTreeUrl, shortGitSha };
+import { a as AnalyticsSeriesInput, c as CompoundAnalyticsExpression, d as ConversionMetric, f as IAnalyticsStore, i as AnalyticsSeries, l as CompoundAnalyticsInputs, n as AnalyticsOperand, o as AnalyticsSeriesQuery, p as MultiCurrencyConversion, r as AnalyticsQuery, s as AnalyticsUpdateCallback, t as AnalyticsDimension, u as CompoundAnalyticsQuery } from "./types-Bsp8VL2y.js";
+import { $ as AddOperationErrorInput, $i as SetOperationNameInput, $n as MutationMoveOperationArgs, $r as ReorderChangeLogItemsInput, $s as ProcessorApps, $t as DocumentModelOperationExampleAction, A as PHPackageProvider, Aa as UndoRedoAction, Ai as SetModelExtensionInput, An as MakeEmpty, Ar as MutationUpdateStateExampleArgs, At as DeleteOperationErrorAction, B as ServiceActions, Ba as UpgradeDocumentActionInput, Bi as SetNameActionInput, Bn as Mutation, Br as PieceModule, Bt as DocumentModelDocumentModelModule, C as PHConnectPwaUrlPattern, Ca as SkipHeaderOperations, Ci as SetAuthorWebsiteAction, Cn as ISigner, Cr as MutationSetOperationReducerArgs, Ct as DeleteChildDocumentInput, D as PHConnectRenownAdapters, Da as Undo, Di as SetModelDescriptionAction, Dn as IsStateOfType, Dr as MutationUndoArgs, Dt as DeleteModuleAction, E as PHConnectRenown, Ea as SubgraphModule, Ei as SetInitialStateInput, En as IsDocumentOfType, Er as MutationSetStateSchemaArgs, Et as DeleteDocumentActionInput, F as ParsedCmdResult, Fa as UpdateRelationshipAction, Fi as SetModuleDescriptionAction, Fn as Maybe, Fr as OperationsByScope, Ft as DeleteStateExampleAction, G as ActionVerificationHandler, Gi as SetOperationErrorCodeInput, Gn as MutationAddOperationExampleArgs, Gr as RedoAction, Gt as DocumentModelLib, H as ActionErrorCallback, Ha as ValidationError, Hi as SetOperationDescriptionAction, Hn as MutationAddModuleArgs, Hr as Publisher, Ht as DocumentModelHeaderAction, I as PathValidation, Ia as UpdateRelationshipActionInput, Ii as SetModuleDescriptionInput, In as MinimalBackupData, Ir as PartialRecord, It as DeleteStateExampleInput, J as AddChangeLogItemInput, Ji as SetOperationErrorNameAction, Jn as MutationDeleteModuleArgs, Jr as ReducerOptions, Js as IProcessor, Jt as DocumentModelModuleAction, K as Actions, Ki as SetOperationErrorDescriptionAction, Kn as MutationAddStateExampleArgs, Kr as RedoActionInput, Kt as DocumentModelLocalState, L as PowerhouseConfig, La as UpdateStateExampleAction, Li as SetModuleNameAction, Ln as ModuleSpecification, Lr as PartialState, Lt as DocumentAction, M as PHRenownPrivyAdapterConfig, Ma as UpdateChangeLogItemInput, Mi as SetModelIdInput, Mn as MakeOptional, Mr as OperationErrorSpecification, Mt as DeleteOperationExampleAction, N as PHRenownRainbowAdapterConfig, Na as UpdateOperationExampleAction, Ni as SetModelNameAction, Nn as Manifest, Nr as OperationIndex, Nt as DeleteOperationExampleInput, O as PHConnectRuntimeConfig, Oa as UndoAction, Oi as SetModelDescriptionInput, On as LoadFromFile, Or as MutationUpdateChangeLogItemInputArgs, Ot as DeleteModuleInput, P as PackageManagerArgs, Pa as UpdateOperationExampleInput, Pi as SetModelNameInput, Pn as MappedOperation, Pr as OperationSpecification, Pt as DeleteOperationInput, Q as AddOperationErrorAction, Qi as SetOperationNameAction, Qn as MutationDeleteStateExampleArgs, Qr as ReorderChangeLogItemsAction, Qs as ProcessorApp, Qt as DocumentModelOperationErrorOperations, R as PowerhousePackage, Ra as UpdateStateExampleInput, Ri as SetModuleNameInput, Rn as MoveOperationAction, Rr as PhAiToolAnnotations, Rt as DocumentModelAction, S as PHConnectPwaRuntimeCaching, Sa as SkipHeaderOperationIndex, Si as SetAuthorNameInput, Sn as ISignalResult, Sr as MutationSetOperationNameArgs, St as DeleteChangeLogItemInput, T as PHConnectReactorFeatureFlags, Ta as StateReducer, Ti as SetInitialStateAction, Tn as InputMaybe, Tr as MutationSetOperationTemplateArgs, Tt as DeleteDocumentAction, U as ActionSignatureContext, Ui as SetOperationDescriptionInput, Un as MutationAddOperationArgs, Ur as Query, Ut as DocumentModelHeaderOperations, Va as User, Vi as SetNameOperation, Vn as MutationAddChangeLogItemInputArgs, Vr as PowerhouseModule, Vt as DocumentModelGlobalState, W as ActionSigningHandler, Wi as SetOperationErrorCodeAction, Wn as MutationAddOperationErrorArgs, Wr as Redo, Wt as DocumentModelInput, X as AddModuleInput, Xi as SetOperationErrorTemplateAction, Xn as MutationDeleteOperationErrorArgs, Xr as RemoveRelationshipAction, Xs as IProcessorHostModuleBase, Xt as DocumentModelOperationAction, Y as AddModuleAction, Yi as SetOperationErrorNameInput, Yn as MutationDeleteOperationArgs, Yr as ReleaseNewVersionAction, Ys as IProcessorDispatch, Yt as DocumentModelModuleOperations, Z as AddOperationAction, Zi as SetOperationErrorTemplateInput, Zn as MutationDeleteOperationExampleArgs, Zr as RemoveRelationshipActionInput, Zs as IProcessorManager, Zt as DocumentModelOperationErrorAction, _ as PHConnectPwa, _a as SignalResult, _i as SchemaSetNameAction, _n as IAction, _r as MutationSetOperationDescriptionArgs, _t as CreateDocument, a as PHConnectAi, aa as SetOperationScopeInput, ac as ProcessorStatus, ai as ReorderOperationErrorsInput, an as DocumentModelUtils, ar as MutationReorderOperationExamplesArgs, at as AddStateExampleAction, b as PHConnectPwaIcon, ba as SignatureVerificationHandler, bi as ScopeState, bn as IOperation, br as MutationSetOperationErrorNameArgs, bt as CreateState, c as PHConnectDefaultDrive, ca as SetPreferredEditorAction, ci as ReorderStateExamplesAction, cn as DocumentOperationsIgnoreMap, cr as MutationSetAuthorWebsiteArgs, ct as AssertIsStateOfType, d as PHConnectDriveSection, da as SetStateSchemaAction, di as RevisionsFilter, dn as EditorDispatch, dr as MutationSetModelExtensionArgs, dt as ConfigEntry, ea as SetOperationReducerAction, ec as ProcessorDispatchResult, ei as ReorderModuleOperationsAction, en as DocumentModelOperationExampleOperations, er as MutationRedoArgs, et as AddOperationExampleAction, f as PHConnectDriveSections, fa as SetStateSchemaInput, fi as SaveToFile, fn as EditorModule, fr as MutationSetModelIdArgs, ft as ConfigEntryType, g as PHConnectPackages, ga as SignalDispatch, gi as SchemaRedoAction, gn as GetDocumentOptions, gr as MutationSetNameArgs, gt as CreateChildDocumentSignal, h as PHConnectOpenPanel, ha as Signal, hi as SchemaNOOPAction, hn as FileInput, hr as MutationSetModuleNameArgs, ht as CreateChildDocumentInput, i as LogLevels, ia as SetOperationScopeAction, ic as ProcessorRecord, ii as ReorderOperationErrorsAction, in as DocumentModelStateOperations, ir as MutationReorderOperationErrorsArgs, it as AddRelationshipActionInput, j as PHReactorRenown, ja as UpdateChangeLogItemAction, ji as SetModelIdAction, jn as MakeMaybe, jr as NOOPAction, jt as DeleteOperationErrorInput, k as PHConnectSentry, ka as UndoActionInput, ki as SetModelExtensionAction, kn as LoadFromInput, kr as MutationUpdateOperationExampleArgs, kt as DeleteOperationAction, l as PHConnectDefaultDriveLocal, la as SetPreferredEditorActionInput, li as ReorderStateExamplesInput, ln as DocumentSpecification, lr as MutationSetInitialStateArgs, lt as Author, m as PHConnectInstance, ma as Set_PreferredEditor, mi as Scalars, mn as Exact, mr as MutationSetModuleDescriptionArgs, mt as CopyChildDocumentSignal, n as DrivePreserveStrategy, na as SetOperationSchemaAction, nc as ProcessorFactoryBuilder, ni as ReorderModulesAction, nn as DocumentModelPHState, nr as MutationReorderModuleOperationsArgs, nt as AddOperationInput, o as PHConnectApp, oa as SetOperationTemplateAction, oc as TrackedProcessor, oi as ReorderOperationExamplesAction, on as DocumentModelVersioningAction, or as MutationReorderStateExamplesArgs, ot as AddStateExampleInput, p as PHConnectDrives, pa as Set_Name, pi as SaveToFileHandle, pn as EditorProps, pr as MutationSetModelNameArgs, pt as CopyChildDocumentInput, q as AddChangeLogItemAction, qi as SetOperationErrorDescriptionInput, qn as MutationDeleteChangeLogItemInputArgs, qr as Reducer, qt as DocumentModelModule, r as LogLevel, ra as SetOperationSchemaInput, rc as ProcessorFilter, ri as ReorderModulesInput, rn as DocumentModelStateAction, rr as MutationReorderModulesArgs, rt as AddRelationshipAction, s as PHConnectBranding, sa as SetOperationTemplateInput, si as ReorderOperationExamplesInput, sn as DocumentModelVersioningOperations, sr as MutationSetAuthorNameArgs, st as AssertIsDocumentOfType, t as DrivePreserveStrategies, ta as SetOperationReducerInput, tc as ProcessorFactory, ti as ReorderModuleOperationsInput, tn as DocumentModelOperationOperations, tr as MutationReorderChangeLogItemsInputArgs, tt as AddOperationExampleInput, u as PHConnectDefaultDriveRemote, ua as SetPreferredEditorOperation, ui as ReplayDocumentOptions, un as ENSInfo, ur as MutationSetModelDescriptionArgs, ut as CodeExample, v as PHConnectPwaCacheStrategy, va as SignalResults, vi as SchemaSetPreferredEditorAction, vn as ID, vr as MutationSetOperationErrorCodeArgs, vt as CreateDocumentAction, w as PHConnectReactor, wa as State, wi as SetAuthorWebsiteInput, wn as Incremental, wr as MutationSetOperationSchemaArgs, wt as DeleteChildDocumentSignal, x as PHConnectPwaManifest, xa as SigningParameters, xi as SetAuthorNameAction, xn as ISignal, xr as MutationSetOperationErrorTemplateArgs, xt as DeleteChangeLogItemAction, y as PHConnectPwaFileHandler, ya as SignalType, yi as SchemaUndoAction, yn as IDocument, yr as MutationSetOperationErrorDescriptionArgs, yt as CreateDocumentActionInput, z as ServiceAction, za as UpgradeDocumentAction, zi as SetNameAction, zn as MoveOperationInput, zr as PhAiToolDescriptor, zt as DocumentModelDocument } from "./types-CmeoQg_J.js";
+import { i as PACKAGES_DEPENDENCIES, n as APPS_DEPENDENCIES, r as CLIS_DEPENDENCIES, t as ALL_POWERHOUSE_DEPENDENCIES } from "./constants-DO4IYxuR.js";
+import { $ as DeleteNodeAction, A as TriggerData, B as RegistryPackageMap, C as RemoveTriggerInput, D as SetSharingTypeInput, E as SetDriveNameInput, F as PackageInfo, G as DocumentDriveAction, H as RegistryPackageStatus, I as PackageListItem, J as LegacyAddFileInput, K as DocumentDriveDocument, L as PackagePage, M as TriggerType, N as UpdateFileInput, O as TransmitterType, P as UpdateNodeInput, Q as CopyNodeAction, R as RegistryPackage, S as RemoveListenerInput, T as SetDriveIconInput, U as DocumentDrivePHState, V as RegistryPackageSource, W as DriveDocumentModelModule, X as AddFileAction, Y as LegacySynchronizationUnit, Z as AddFolderAction, _ as ListenerInput, a as CopyNodeInput, at as AddListenerAction, b as PullResponderTriggerData, c as DocumentDriveLocalState, ct as DocumentDriveDriveOperations, d as FolderNode, dt as SetAvailableOfflineAction, et as DocumentDriveNodeAction, f as Listener, ft as SetDriveIconAction, g as ListenerFilterInput, h as ListenerFilter, i as AddTriggerInput, it as UpdateNodeAction, j as TriggerInput, k as Trigger, lt as RemoveListenerAction, m as ListenerCallInfoInput, mt as SetSharingTypeAction, n as AddFolderInput, nt as MoveNodeAction, o as DeleteNodeInput, ot as AddTriggerAction, p as ListenerCallInfo, pt as SetDriveNameAction, q as LegacyAddFileAction, r as AddListenerInput, rt as UpdateFileAction, s as DocumentDriveGlobalState, st as DocumentDriveDriveAction, t as AddFileInput, tt as DocumentDriveNodeOperations, u as FileNode, ut as RemoveTriggerAction, v as MoveNodeInput, w as SetAvailableOfflineInput, x as PullResponderTriggerDataInput, y as Node, z as RegistryPackageList } from "./types-CI3ren9F.js";
+import { a as GenerateNodesCopyIdGenerator, i as DriveInput, n as buildTreeUrl, o as GenerateNodesCopySrc, r as shortGitSha, s as SharingType, t as GITHUB_REPO_URL } from "./index-5gwOhPG5.js";
+export { ALL_POWERHOUSE_DEPENDENCIES, APPS_DEPENDENCIES, type ActionErrorCallback, type ActionSignatureContext, type ActionSigningHandler, type ActionVerificationHandler, type Actions, type AddChangeLogItemAction, type AddChangeLogItemInput, type AddFileAction, type AddFileInput, type AddFolderAction, type AddFolderInput, type AddListenerAction, type AddListenerInput, type AddModuleAction, type AddModuleInput, type AddOperationAction, type AddOperationErrorAction, type AddOperationErrorInput, type AddOperationExampleAction, type AddOperationExampleInput, type AddOperationInput, type AddRelationshipAction, type AddRelationshipActionInput, type AddStateExampleAction, type AddStateExampleInput, type AddTriggerAction, type AddTriggerInput, type AnalyticsDimension, type AnalyticsOperand, type AnalyticsQuery, type AnalyticsSeries, type AnalyticsSeriesInput, type AnalyticsSeriesQuery, type AnalyticsUpdateCallback, type AssertIsDocumentOfType, type AssertIsStateOfType, type Author, CLIS_DEPENDENCIES, type CodeExample, type CompoundAnalyticsExpression, type CompoundAnalyticsInputs, type CompoundAnalyticsQuery, type ConfigEntry, type ConfigEntryType, type ConversionMetric, type CopyChildDocumentInput, type CopyChildDocumentSignal, type CopyNodeAction, type CopyNodeInput, type CreateChildDocumentInput, type CreateChildDocumentSignal, type CreateDocument, type CreateDocumentAction, type CreateDocumentActionInput, type CreateState, type DeleteChangeLogItemAction, type DeleteChangeLogItemInput, type DeleteChildDocumentInput, type DeleteChildDocumentSignal, type DeleteDocumentAction, type DeleteDocumentActionInput, type DeleteModuleAction, type DeleteModuleInput, type DeleteNodeAction, type DeleteNodeInput, type DeleteOperationAction, type DeleteOperationErrorAction, type DeleteOperationErrorInput, type DeleteOperationExampleAction, type DeleteOperationExampleInput, type DeleteOperationInput, type DeleteStateExampleAction, type DeleteStateExampleInput, type DocumentAction, type DocumentDriveAction, type DocumentDriveDocument, type DocumentDriveDriveAction, type DocumentDriveDriveOperations, type DocumentDriveGlobalState, type DocumentDriveLocalState, type DocumentDriveNodeAction, type DocumentDriveNodeOperations, type DocumentDrivePHState, type DocumentModelAction, type DocumentModelDocument, type DocumentModelDocumentModelModule, type DocumentModelGlobalState, type DocumentModelHeaderAction, type DocumentModelHeaderOperations, type DocumentModelInput, type DocumentModelLib, type DocumentModelLocalState, type DocumentModelModule, type DocumentModelModuleAction, type DocumentModelModuleOperations, type DocumentModelOperationAction, type DocumentModelOperationErrorAction, type DocumentModelOperationErrorOperations, type DocumentModelOperationExampleAction, type DocumentModelOperationExampleOperations, type DocumentModelOperationOperations, type DocumentModelPHState, type DocumentModelStateAction, type DocumentModelStateOperations, type DocumentModelUtils, type DocumentModelVersioningAction, type DocumentModelVersioningOperations, type DocumentOperationsIgnoreMap, type DocumentSpecification, type DriveDocumentModelModule, type DriveInput, type DrivePreserveStrategies, type DrivePreserveStrategy, type ENSInfo, type EditorDispatch, type EditorModule, type EditorProps, type Exact, type FileInput, type FileNode, type FolderNode, GITHUB_REPO_URL, type GenerateNodesCopyIdGenerator, type GenerateNodesCopySrc, type GetDocumentOptions, type IAction, type IAnalyticsStore, type ID, type IDocument, type IOperation, type IProcessor, type IProcessorDispatch, type IProcessorHostModuleBase, type IProcessorManager, type ISignal, type ISignalResult, type ISigner, type Incremental, type InputMaybe, type IsDocumentOfType, type IsStateOfType, type LegacyAddFileAction, type LegacyAddFileInput, type LegacySynchronizationUnit, type Listener, type ListenerCallInfo, type ListenerCallInfoInput, type ListenerFilter, type ListenerFilterInput, type ListenerInput, type LoadFromFile, type LoadFromInput, type LogLevel, type LogLevels, type MakeEmpty, type MakeMaybe, type MakeOptional, type Manifest, type MappedOperation, type Maybe, type MinimalBackupData, type ModuleSpecification, type MoveNodeAction, type MoveNodeInput, type MoveOperationAction, type MoveOperationInput, type MultiCurrencyConversion, type Mutation, type MutationAddChangeLogItemInputArgs, type MutationAddModuleArgs, type MutationAddOperationArgs, type MutationAddOperationErrorArgs, type MutationAddOperationExampleArgs, type MutationAddStateExampleArgs, type MutationDeleteChangeLogItemInputArgs, type MutationDeleteModuleArgs, type MutationDeleteOperationArgs, type MutationDeleteOperationErrorArgs, type MutationDeleteOperationExampleArgs, type MutationDeleteStateExampleArgs, type MutationMoveOperationArgs, type MutationRedoArgs, type MutationReorderChangeLogItemsInputArgs, type MutationReorderModuleOperationsArgs, type MutationReorderModulesArgs, type MutationReorderOperationErrorsArgs, type MutationReorderOperationExamplesArgs, type MutationReorderStateExamplesArgs, type MutationSetAuthorNameArgs, type MutationSetAuthorWebsiteArgs, type MutationSetInitialStateArgs, type MutationSetModelDescriptionArgs, type MutationSetModelExtensionArgs, type MutationSetModelIdArgs, type MutationSetModelNameArgs, type MutationSetModuleDescriptionArgs, type MutationSetModuleNameArgs, type MutationSetNameArgs, type MutationSetOperationDescriptionArgs, type MutationSetOperationErrorCodeArgs, type MutationSetOperationErrorDescriptionArgs, type MutationSetOperationErrorNameArgs, type MutationSetOperationErrorTemplateArgs, type MutationSetOperationNameArgs, type MutationSetOperationReducerArgs, type MutationSetOperationSchemaArgs, type MutationSetOperationTemplateArgs, type MutationSetStateSchemaArgs, type MutationUndoArgs, type MutationUpdateChangeLogItemInputArgs, type MutationUpdateOperationExampleArgs, type MutationUpdateStateExampleArgs, type NOOPAction, type Node, type OperationErrorSpecification, type OperationIndex, type OperationSpecification, type OperationsByScope, PACKAGES_DEPENDENCIES, type PHConnectAi, type PHConnectApp, type PHConnectBranding, type PHConnectDefaultDrive, type PHConnectDefaultDriveLocal, type PHConnectDefaultDriveRemote, type PHConnectDriveSection, type PHConnectDriveSections, type PHConnectDrives, type PHConnectInstance, type PHConnectOpenPanel, type PHConnectPackages, type PHConnectPwa, type PHConnectPwaCacheStrategy, type PHConnectPwaFileHandler, type PHConnectPwaIcon, type PHConnectPwaManifest, type PHConnectPwaRuntimeCaching, type PHConnectPwaUrlPattern, type PHConnectReactor, type PHConnectReactorFeatureFlags, type PHConnectRenown, type PHConnectRenownAdapters, type PHConnectRuntimeConfig, type PHConnectSentry, type PHPackageProvider, type PHReactorRenown, type PHRenownPrivyAdapterConfig, type PHRenownRainbowAdapterConfig, type PackageInfo, type PackageListItem, type PackageManagerArgs, type PackagePage, type ParsedCmdResult, type PartialRecord, type PartialState, type PathValidation, type PhAiToolAnnotations, type PhAiToolDescriptor, type PieceModule, type PowerhouseConfig, type PowerhouseModule, type PowerhousePackage, type ProcessorApp, type ProcessorApps, type ProcessorDispatchResult, type ProcessorFactory, type ProcessorFactoryBuilder, type ProcessorFilter, type ProcessorRecord, type ProcessorStatus, type Publisher, type PullResponderTriggerData, type PullResponderTriggerDataInput, type Query, type Redo, type RedoAction, type RedoActionInput, type Reducer, type ReducerOptions, type RegistryPackage, type RegistryPackageList, type RegistryPackageMap, type RegistryPackageSource, type RegistryPackageStatus, type ReleaseNewVersionAction, type RemoveListenerAction, type RemoveListenerInput, type RemoveRelationshipAction, type RemoveRelationshipActionInput, type RemoveTriggerAction, type RemoveTriggerInput, type ReorderChangeLogItemsAction, type ReorderChangeLogItemsInput, type ReorderModuleOperationsAction, type ReorderModuleOperationsInput, type ReorderModulesAction, type ReorderModulesInput, type ReorderOperationErrorsAction, type ReorderOperationErrorsInput, type ReorderOperationExamplesAction, type ReorderOperationExamplesInput, type ReorderStateExamplesAction, type ReorderStateExamplesInput, type ReplayDocumentOptions, type RevisionsFilter, type SaveToFile, type SaveToFileHandle, type Scalars, type SchemaNOOPAction, type SchemaRedoAction, type SchemaSetNameAction, type SchemaSetPreferredEditorAction, type SchemaUndoAction, type ScopeState, type ServiceAction, type ServiceActions, type SetAuthorNameAction, type SetAuthorNameInput, type SetAuthorWebsiteAction, type SetAuthorWebsiteInput, type SetAvailableOfflineAction, type SetAvailableOfflineInput, type SetDriveIconAction, type SetDriveIconInput, type SetDriveNameAction, type SetDriveNameInput, type SetInitialStateAction, type SetInitialStateInput, type SetModelDescriptionAction, type SetModelDescriptionInput, type SetModelExtensionAction, type SetModelExtensionInput, type SetModelIdAction, type SetModelIdInput, type SetModelNameAction, type SetModelNameInput, type SetModuleDescriptionAction, type SetModuleDescriptionInput, type SetModuleNameAction, type SetModuleNameInput, type SetNameAction, type SetNameActionInput, type SetNameOperation, type SetOperationDescriptionAction, type SetOperationDescriptionInput, type SetOperationErrorCodeAction, type SetOperationErrorCodeInput, type SetOperationErrorDescriptionAction, type SetOperationErrorDescriptionInput, type SetOperationErrorNameAction, type SetOperationErrorNameInput, type SetOperationErrorTemplateAction, type SetOperationErrorTemplateInput, type SetOperationNameAction, type SetOperationNameInput, type SetOperationReducerAction, type SetOperationReducerInput, type SetOperationSchemaAction, type SetOperationSchemaInput, type SetOperationScopeAction, type SetOperationScopeInput, type SetOperationTemplateAction, type SetOperationTemplateInput, type SetPreferredEditorAction, type SetPreferredEditorActionInput, type SetPreferredEditorOperation, type SetSharingTypeAction, type SetSharingTypeInput, type SetStateSchemaAction, type SetStateSchemaInput, type Set_Name, type Set_PreferredEditor, type SharingType, type Signal, type SignalDispatch, type SignalResult, type SignalResults, type SignalType, type SignatureVerificationHandler, type SigningParameters, type SkipHeaderOperationIndex, type SkipHeaderOperations, type State, type StateReducer, type SubgraphModule, type TrackedProcessor, type TransmitterType, type Trigger, type TriggerData, type TriggerInput, type TriggerType, type Undo, type UndoAction, type UndoActionInput, type UndoRedoAction, type UpdateChangeLogItemAction, type UpdateChangeLogItemInput, type UpdateFileAction, type UpdateFileInput, type UpdateNodeAction, type UpdateNodeInput, type UpdateOperationExampleAction, type UpdateOperationExampleInput, type UpdateRelationshipAction, type UpdateRelationshipActionInput, type UpdateStateExampleAction, type UpdateStateExampleInput, type UpgradeDocumentAction, type UpgradeDocumentActionInput, type User, type ValidationError, buildTreeUrl, shortGitSha };
+export {};

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../git.ts"],"sourcesContent":["export const GITHUB_REPO_URL = \"https://github.com/powerhouse-inc/powerhouse\";\n\nexport function buildTreeUrl(sha: string): string | null {\n  if (!sha || sha === \"unknown\") return null;\n  return `${GITHUB_REPO_URL}/tree/${sha}`;\n}\n\nexport function shortGitSha(sha: string): string {\n  return sha === \"unknown\" ? sha : sha.slice(0, 7);\n}\n"],"mappings":";;AAAA,MAAa,kBAAkB;AAE/B,SAAgB,aAAa,KAA4B;AACvD,KAAI,CAAC,OAAO,QAAQ,UAAW,QAAO;AACtC,QAAO,GAAG,gBAAgB,QAAQ;;AAGpC,SAAgB,YAAY,KAAqB;AAC/C,QAAO,QAAQ,YAAY,MAAM,IAAI,MAAM,GAAG,EAAE"}
+{"version":3,"file":"index.js","names":[],"sources":["../git.ts"],"sourcesContent":["export const GITHUB_REPO_URL = \"https://github.com/powerhouse-inc/powerhouse\";\n\nexport function buildTreeUrl(sha: string): string | null {\n  if (!sha || sha === \"unknown\") return null;\n  return `${GITHUB_REPO_URL}/tree/${sha}`;\n}\n\nexport function shortGitSha(sha: string): string {\n  return sha === \"unknown\" ? sha : sha.slice(0, 7);\n}\n"],"mappings":";;AAAA,MAAa,kBAAkB;AAE/B,SAAgB,aAAa,KAA4B;CACvD,IAAI,CAAC,OAAO,QAAQ,WAAW,OAAO;CACtC,OAAO,GAAG,gBAAgB,QAAQ;AACpC;AAEA,SAAgB,YAAY,KAAqB;CAC/C,OAAO,QAAQ,YAAY,MAAM,IAAI,MAAM,GAAG,CAAC;AACjD"}

package/dist/processors/index.d.ts

@@ -1,2 +1,3 @@
-import { $s as ProcessorDispatchResult, Ac as WebhookSignatureEncoding, Bs as IBaseRelationalDb, Cc as WebhookEndpointInfo, Cd as DEFAULT_ANALYTICS_PROCESSOR_DB_NAME, Dc as WebhookReply, Ec as WebhookPolicy, Fs as createRelationalDb, Gs as RelationalDbProcessor, Hs as IRelationalDbProcessor, Is as hashNamespace, Js as IProcessorDispatch, Ks as RelationalDbProcessorClass, Ls as relationalDbToQueryBuilder, Mc as WebhookVerification, Ns as createNamespacedDb, Oc as WebhookRequest, Ps as createNamespacedQueryBuilder, Qs as ProcessorApps, Rs as ExtractProcessorSchemaOrSelf, Sc as ScopedRouteHandle, Tc as WebhookHashAlgorithm, Td as PROCESSOR_APPS, Us as IRelationalQueryBuilder, Vs as IRelationalDb, Ws as IRelationalQueryMethods, Xs as IProcessorManager, Ys as IProcessorHostModuleBase, Zs as ProcessorApp, _c as RouteMethod, ac as TrackedProcessor, bc as RouteTransport, cc as IWebhookEndpoints, dc as RouteActor, ec as ProcessorFactory, fc as RouteAuth, gc as RouteHandler, hc as RouteContext, ic as ProcessorStatus, jc as WebhookSpec, kc as WebhookScheme, lc as IWebhookScope, mc as RouteBody, nc as ProcessorFilter, oc as AuthorizerResult, pc as RouteAuthorizer, qs as IProcessor, rc as ProcessorRecord, sc as IHttpScope, tc as ProcessorFactoryBuilder, uc as NodeRouteSpec, vc as RouteOptions, wc as WebhookField, wd as DEFAULT_RELATIONAL_PROCESSOR_DB_NAME, xc as RouteUser, yc as RouteSpec, zs as HashAlgorithms } from "../types-BIoOWpOT.js";
-export { AuthorizerResult, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME, ExtractProcessorSchemaOrSelf, HashAlgorithms, IBaseRelationalDb, IHttpScope, IProcessor, IProcessorDispatch, IProcessorHostModuleBase, IProcessorManager, IRelationalDb, IRelationalDbProcessor, IRelationalQueryBuilder, IRelationalQueryMethods, IWebhookEndpoints, IWebhookScope, NodeRouteSpec, PROCESSOR_APPS, ProcessorApp, ProcessorApps, ProcessorDispatchResult, ProcessorFactory, ProcessorFactoryBuilder, ProcessorFilter, ProcessorRecord, ProcessorStatus, RelationalDbProcessor, RelationalDbProcessorClass, RouteActor, RouteAuth, RouteAuthorizer, RouteBody, RouteContext, RouteHandler, RouteMethod, RouteOptions, RouteSpec, RouteTransport, RouteUser, ScopedRouteHandle, TrackedProcessor, WebhookEndpointInfo, WebhookField, WebhookHashAlgorithm, WebhookPolicy, WebhookReply, WebhookRequest, WebhookScheme, WebhookSignatureEncoding, WebhookSpec, WebhookVerification, createNamespacedDb, createNamespacedQueryBuilder, createRelationalDb, hashNamespace, relationalDbToQueryBuilder };
+import { $s as ProcessorApps, Ac as WebhookScheme, Bs as HashAlgorithms, Cc as ScopedRouteHandle, Dc as WebhookPolicy, Ec as WebhookHashAlgorithm, Fd as DEFAULT_ANALYTICS_PROCESSOR_DB_NAME, Fs as createNamespacedQueryBuilder, Gs as IRelationalQueryMethods, Hs as IRelationalDb, Id as DEFAULT_RELATIONAL_PROCESSOR_DB_NAME, Is as createRelationalDb, Js as IProcessor, Ks as RelationalDbProcessor, Ld as PROCESSOR_APPS, Ls as hashNamespace, Mc as WebhookSpec, Nc as WebhookVerification, Oc as WebhookReply, Ps as createNamespacedDb, Qs as ProcessorApp, Rs as relationalDbToQueryBuilder, Sc as RouteUser, Tc as WebhookField, Us as IRelationalDbProcessor, Vs as IBaseRelationalDb, Ws as IRelationalQueryBuilder, Xs as IProcessorHostModuleBase, Ys as IProcessorDispatch, Zs as IProcessorManager, _c as RouteHandler, ac as ProcessorStatus, bc as RouteSpec, cc as IHttpScope, dc as NodeRouteSpec, ec as ProcessorDispatchResult, fc as RouteActor, gc as RouteContext, hc as RouteBody, ic as ProcessorRecord, jc as WebhookSignatureEncoding, kc as WebhookRequest, lc as IWebhookEndpoints, mc as RouteAuthorizer, nc as ProcessorFactoryBuilder, oc as TrackedProcessor, pc as RouteAuth, qs as RelationalDbProcessorClass, rc as ProcessorFilter, sc as AuthorizerResult, tc as ProcessorFactory, uc as IWebhookScope, vc as RouteMethod, wc as WebhookEndpointInfo, xc as RouteTransport, yc as RouteOptions, zs as ExtractProcessorSchemaOrSelf } from "../types-CmeoQg_J.js";
+export { type AuthorizerResult, DEFAULT_ANALYTICS_PROCESSOR_DB_NAME, DEFAULT_RELATIONAL_PROCESSOR_DB_NAME, ExtractProcessorSchemaOrSelf, HashAlgorithms, IBaseRelationalDb, type IHttpScope, type IProcessor, type IProcessorDispatch, type IProcessorHostModuleBase, type IProcessorManager, IRelationalDb, IRelationalDbProcessor, IRelationalQueryBuilder, IRelationalQueryMethods, type IWebhookEndpoints, type IWebhookScope, type NodeRouteSpec, PROCESSOR_APPS, type ProcessorApp, type ProcessorApps, type ProcessorDispatchResult, type ProcessorFactory, type ProcessorFactoryBuilder, type ProcessorFilter, type ProcessorRecord, type ProcessorStatus, RelationalDbProcessor, RelationalDbProcessorClass, type RouteActor, type RouteAuth, type RouteAuthorizer, type RouteBody, type RouteContext, type RouteHandler, type RouteMethod, type RouteOptions, type RouteSpec, type RouteTransport, type RouteUser, type ScopedRouteHandle, type TrackedProcessor, type WebhookEndpointInfo, type WebhookField, type WebhookHashAlgorithm, type WebhookPolicy, type WebhookReply, type WebhookRequest, type WebhookScheme, type WebhookSignatureEncoding, type WebhookSpec, type WebhookVerification, createNamespacedDb, createNamespacedQueryBuilder, createRelationalDb, hashNamespace, relationalDbToQueryBuilder };
+export {};

package/dist/processors/index.js

@@ -23,7 +23,8 @@ const LOG2_26 = Math.log2(26);
 */
 function hashNamespace(str, length = 10) {
 	const requiredBits = Math.ceil(length * LOG2_26);
-	return toBase26(fnv1a(str, { size: SUPPORTED_SIZES.find((size) => size && size >= requiredBits) ?? 1024 }), length);
+	const bitSize = SUPPORTED_SIZES.find((size) => size && size >= requiredBits) ?? 1024;
+	return toBase26(fnv1a(str, { size: bitSize }), length);
 }
 function toBase26(num, length = 10) {
 	const alphabet = "abcdefghijklmnopqrstuvwxyz";
@@ -78,6 +79,9 @@ const IS_RELATIONAL_DB_PROCESSOR = Symbol.for("ph.IS_RELATIONAL_DB_PROCESSOR");
 * allowing derived classes to focus on business logic.
 */
 var RelationalDbProcessor = class {
+	_namespace;
+	_filter;
+	relationalDb;
 	constructor(_namespace, _filter, relationalDb) {
 		this._namespace = _namespace;
 		this._filter = _filter;