@phosphorco/bb-identity 0.1.0

package/dist/state-transport-runtime.js

@@ -0,0 +1,349 @@
+// @bun
+// model-runtime.ts
+var ID_MAX_LENGTH = 256;
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
+function failure(code, message, retry = "never") {
+  return { code, message, retry };
+}
+function ok(value) {
+  return { ok: true, value };
+}
+function err(code, message, retry = "never") {
+  return { ok: false, error: failure(code, message, retry) };
+}
+function isBoundedString(value, maximum = ID_MAX_LENGTH) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximum;
+}
+function idCodec(kind) {
+  return {
+    decode(input) {
+      const valid = kind === "server-session" ? isBoundedString(input, 4096) && !/[\u0000-\u0020\u007f]/.test(input) : isBoundedString(input) && ID_PATTERN.test(input);
+      if (!valid) {
+        return err("invalid-input", `Invalid ${kind} identifier.`);
+      }
+      return ok(input);
+    },
+    encode(value) {
+      return value;
+    }
+  };
+}
+var identityKeyCodec = {
+  decode(input) {
+    if (!isBoundedString(input, 512) || /[\u0000-\u001f\u007f]/.test(input)) {
+      return err("invalid-input", "Invalid identity key.");
+    }
+    return ok(input);
+  },
+  encode(value) {
+    return value;
+  }
+};
+
+// state-service-runtime.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function decodeAddress(value) {
+  if (!isRecord(value) || !nonEmpty(value.collection) || !nonEmpty(value.recordId))
+    return err("invalid-input", "Invalid state address.");
+  const instanceId = idCodec("instance").decode(value.instanceId);
+  const pluginId = idCodec("plugin").decode(value.pluginId);
+  const owner = identityKeyCodec.decode(value.owner);
+  return instanceId.ok && pluginId.ok && owner.ok ? ok({ instanceId: instanceId.value, pluginId: pluginId.value, collection: value.collection, recordId: value.recordId, owner: owner.value }) : err("invalid-input", "Invalid state address identifiers.");
+}
+function decodeVersion(value) {
+  return isRecord(value) && nonEmpty(value.epoch) && typeof value.sequence === "number" && Number.isInteger(value.sequence) && value.sequence >= 0 ? ok({ epoch: value.epoch, sequence: value.sequence }) : err("invalid-input", "Invalid state version.");
+}
+function decodeActor(value) {
+  if (value === null)
+    return ok(null);
+  if (!isRecord(value) || !isRecord(value.identity) || !isRecord(value.presentation) || !nonEmpty(value.presentation.displayName) || value.presentation.handle !== null && typeof value.presentation.handle !== "string" || value.presentation.avatarUrl !== null && typeof value.presentation.avatarUrl !== "string" || !["provider-verified", "local-user", "upstream-default", "integration-asserted", "legacy", "machine"].includes(value.evidence)) {
+    return err("invalid-input", "Invalid state editor snapshot.");
+  }
+  const key = identityKeyCodec.decode(value.identity.key);
+  if (!key.ok)
+    return key;
+  const identity = value.identity;
+  const presentation = { displayName: value.presentation.displayName, handle: value.presentation.handle, avatarUrl: value.presentation.avatarUrl };
+  if (identity.kind === "machine") {
+    const instanceId = idCodec("instance").decode(identity.instanceId);
+    if (!instanceId.ok || value.evidence !== "machine" || identity.hostId !== null && (typeof identity.hostId !== "string" || identity.hostId.length === 0 || identity.hostId.length > 512)) {
+      return err("invalid-input", "Invalid machine editor identity.");
+    }
+    return ok({ identity: { kind: "machine", key: key.value, instanceId: instanceId.value, hostId: identity.hostId }, presentation, evidence: "machine" });
+  }
+  if (value.evidence === "machine")
+    return err("invalid-input", "Machine evidence requires a machine identity.");
+  if (identity.kind === "person" && nonEmpty(identity.issuer) && nonEmpty(identity.subject)) {
+    return ok({ identity: { kind: "person", key: key.value, issuer: identity.issuer, subject: identity.subject }, presentation, evidence: value.evidence });
+  }
+  if (identity.kind === "default-user") {
+    const instanceId = idCodec("instance").decode(identity.instanceId);
+    return instanceId.ok ? ok({ identity: { kind: "default-user", key: key.value, instanceId: instanceId.value }, presentation, evidence: value.evidence }) : instanceId;
+  }
+  if (identity.kind === "external") {
+    const pluginId = idCodec("plugin").decode(identity.pluginId);
+    return pluginId.ok && nonEmpty(identity.subject) ? ok({ identity: { kind: "external", key: key.value, pluginId: pluginId.value, subject: identity.subject }, presentation, evidence: value.evidence }) : err("invalid-input", "Invalid external editor identity.");
+  }
+  return err("invalid-input", "Invalid editor identity.");
+}
+function decodeEnvelope(value, codec) {
+  if (!isRecord(value) || typeof value.schemaVersion !== "number" || !Number.isInteger(value.schemaVersion) || value.schemaVersion < 0) {
+    return err("invalid-input", "Invalid state envelope.");
+  }
+  const address = decodeAddress(value.address);
+  const version = decodeVersion(value.version);
+  const decoded = codec.decode(value.value);
+  const editor = decodeActor(value.lastEditedBy);
+  return address.ok && version.ok && decoded.ok && editor.ok ? ok({ address: address.value, version: version.value, schemaVersion: value.schemaVersion, value: decoded.value, lastEditedBy: editor.value }) : err("invalid-input", "Invalid state envelope fields.");
+}
+function decodeRead(value, codec) {
+  if (!isRecord(value) || typeof value.status !== "string")
+    return err("invalid-input", "Invalid state read.");
+  if (value.status === "present") {
+    const envelope = decodeEnvelope(value.envelope, codec);
+    return envelope.ok ? ok({ status: "present", envelope: envelope.value }) : envelope;
+  }
+  if (value.status === "empty") {
+    const address = decodeAddress(value.address);
+    const version = decodeVersion(value.version);
+    return address.ok && version.ok ? ok({ status: "empty", address: address.value, version: version.value }) : err("invalid-input", "Invalid empty state read.");
+  }
+  if (value.status === "migration-required") {
+    const address = decodeAddress(value.address);
+    return address.ok && typeof value.storedSchemaVersion === "number" && Number.isInteger(value.storedSchemaVersion) && value.storedSchemaVersion >= 0 ? ok({ status: "migration-required", address: address.value, storedSchemaVersion: value.storedSchemaVersion }) : err("invalid-input", "Invalid migration-required read.");
+  }
+  return err("invalid-input", "Unknown state read status.");
+}
+function decodeMutation(value, codec) {
+  if (!isRecord(value) || value.kind !== "initialize" && value.kind !== "replace" || !isRecord(value.expected) || typeof value.schemaVersion !== "number" || !Number.isInteger(value.schemaVersion) || value.schemaVersion < 0 || typeof value.localGeneration !== "number" || !Number.isInteger(value.localGeneration) || value.localGeneration < 0) {
+    return err("invalid-input", "Invalid state mutation.");
+  }
+  const address = decodeAddress(value.address);
+  const expectedVersion = decodeVersion(value.expectedVersion);
+  const actor = identityKeyCodec.decode(value.expected.actor);
+  const session = idCodec("server-session").decode(value.expected.session);
+  const ownerSession = idCodec("owner-session").decode(value.ownerSession);
+  const operationId = idCodec("operation").decode(value.operationId);
+  const decoded = codec.decode(value.value);
+  return address.ok && expectedVersion.ok && actor.ok && session.ok && ownerSession.ok && operationId.ok && decoded.ok ? ok({
+    kind: value.kind,
+    address: address.value,
+    expectedVersion: expectedVersion.value,
+    expected: { actor: actor.value, session: session.value },
+    ownerSession: ownerSession.value,
+    localGeneration: value.localGeneration,
+    operationId: operationId.value,
+    schemaVersion: value.schemaVersion,
+    value: decoded.value
+  }) : err("invalid-input", "Invalid state mutation fields.");
+}
+function decodeOutcome(value, codec) {
+  if (!isRecord(value) || typeof value.status !== "string")
+    return err("invalid-input", "Invalid state outcome.");
+  const operationId = idCodec("operation").decode(value.operationId);
+  if (!operationId.ok)
+    return operationId;
+  if (value.status === "saved" || value.status === "unchanged") {
+    const envelope = decodeEnvelope(value.envelope, codec);
+    return envelope.ok ? ok({ status: value.status, envelope: envelope.value, operationId: operationId.value }) : envelope;
+  }
+  if (value.status === "already-initialized" || value.status === "conflict") {
+    const current = decodeRead(value.current, codec);
+    return current.ok ? ok({ status: value.status, current: current.value, operationId: operationId.value }) : current;
+  }
+  return err("invalid-input", "Unknown state outcome status.");
+}
+function decodeSave(value, codec) {
+  if (isRecord(value) && value.status === "indeterminate") {
+    const operationId = idCodec("operation").decode(value.operationId);
+    return operationId.ok ? ok({ status: "indeterminate", operationId: operationId.value }) : operationId;
+  }
+  return decodeOutcome(value, codec);
+}
+function decodeLookup(value, codec) {
+  if (!isRecord(value) || typeof value.status !== "string")
+    return err("invalid-input", "Invalid state lookup.");
+  if (value.status === "final") {
+    const outcome = decodeOutcome(value.outcome, codec);
+    return outcome.ok ? ok({ status: "final", outcome: outcome.value }) : outcome;
+  }
+  if (value.status === "pending")
+    return ok({ status: "pending" });
+  if (value.status === "absent-final" && value.retry === "same-operation-only")
+    return ok({ status: "absent-final", retry: "same-operation-only" });
+  if (value.status === "unknown" && (value.reason === "unsupported" || value.reason === "expired" || value.reason === "unavailable"))
+    return ok({ status: "unknown", reason: value.reason });
+  return err("invalid-input", "Invalid state lookup metadata.");
+}
+function encodeAddress(address) {
+  return { instanceId: address.instanceId, pluginId: address.pluginId, collection: address.collection, recordId: address.recordId, owner: address.owner };
+}
+function encodeVersion(version) {
+  return { epoch: version.epoch, sequence: version.sequence };
+}
+function encodeActor(actor) {
+  return actor === null ? null : { identity: actor.identity, presentation: actor.presentation, evidence: actor.evidence };
+}
+function encodeEnvelope(envelope, codec) {
+  return { address: encodeAddress(envelope.address), version: encodeVersion(envelope.version), schemaVersion: envelope.schemaVersion, value: codec.encode(envelope.value), lastEditedBy: encodeActor(envelope.lastEditedBy) };
+}
+function encodeRead(read, codec) {
+  return read.status === "present" ? { status: "present", envelope: encodeEnvelope(read.envelope, codec) } : read.status === "empty" ? { status: "empty", address: encodeAddress(read.address), version: encodeVersion(read.version) } : read.status === "migration-required" ? { status: "migration-required", address: encodeAddress(read.address), storedSchemaVersion: read.storedSchemaVersion } : (() => {
+    throw new TypeError("Invalid state read status.");
+  })();
+}
+function encodeMutation(mutation, codec) {
+  return { ...mutation, address: encodeAddress(mutation.address), expectedVersion: encodeVersion(mutation.expectedVersion), value: codec.encode(mutation.value) };
+}
+function encodeOutcome(outcome, codec) {
+  if (outcome.status === "saved" || outcome.status === "unchanged") {
+    return { status: outcome.status, envelope: encodeEnvelope(outcome.envelope, codec), operationId: outcome.operationId };
+  }
+  if ("current" in outcome)
+    return { status: outcome.status, current: encodeRead(outcome.current, codec), operationId: outcome.operationId };
+  throw new TypeError("Invalid state outcome.");
+}
+function encodeSave(save, codec) {
+  return save.status === "indeterminate" ? { status: "indeterminate", operationId: save.operationId } : encodeOutcome(save, codec);
+}
+function stateCodecs(value) {
+  return {
+    read: { decode: (input) => decodeRead(input, value), encode: (input) => encodeRead(input, value) },
+    mutation: { decode: (input) => decodeMutation(input, value), encode: (input) => encodeMutation(input, value) },
+    save: { decode: (input) => decodeSave(input, value), encode: (input) => encodeSave(input, value) },
+    invalidation: {
+      decode(input) {
+        if (!isRecord(input))
+          return err("invalid-input", "Invalid state invalidation.");
+        const address = decodeAddress(input.address);
+        const version = decodeVersion(input.version);
+        const operationId = input.operationId === null ? ok(null) : idCodec("operation").decode(input.operationId);
+        return address.ok && version.ok && operationId.ok ? ok({ address: address.value, version: version.value, operationId: operationId.value }) : err("invalid-input", "Invalid state invalidation fields.");
+      },
+      encode: (input) => ({ address: encodeAddress(input.address), version: encodeVersion(input.version), operationId: input.operationId })
+    },
+    lookup: {
+      decode: (input) => decodeLookup(input, value),
+      encode: (input) => input.status === "final" ? { status: "final", outcome: encodeOutcome(input.outcome, value) } : input
+    }
+  };
+}
+
+// rpc-routes-runtime.ts
+var identityRoutes = Object.freeze({
+  bootstrap: "bb-identity/v1/bootstrap",
+  selfProfile: "bb-identity/v1/selfProfile",
+  search: "bb-identity/v1/search",
+  profiles: "bb-identity/v1/profiles",
+  participants: "bb-identity/v1/participants",
+  participantPreviews: "bb-identity/v1/participantPreviews"
+});
+var identityStateRoutes = Object.freeze({
+  load: "bb-identity/v1/state/load",
+  save: "bb-identity/v1/state/save",
+  reconcile: "bb-identity/v1/state/reconcile"
+});
+var identityStateRpcMethods = Object.freeze({
+  [identityStateRoutes.load]: "bb-identity.v1.state.load",
+  [identityStateRoutes.save]: "bb-identity.v1.state.save",
+  [identityStateRoutes.reconcile]: "bb-identity.v1.state.reconcile"
+});
+var identityRpcMethods = Object.freeze({
+  [identityRoutes.bootstrap]: "bb-identity.v1.bootstrap",
+  [identityRoutes.selfProfile]: "bb-identity.v1.selfProfile",
+  [identityRoutes.search]: "bb-identity.v1.search",
+  [identityRoutes.profiles]: "bb-identity.v1.profiles",
+  [identityRoutes.participants]: "bb-identity.v1.participants",
+  [identityRoutes.participantPreviews]: "bb-identity.v1.participantPreviews",
+  ...identityStateRpcMethods
+});
+
+// state-transport-runtime.ts
+function writeUnavailable(connection) {
+  const health = connection.getHealth();
+  if (health.identity.status === "healthy" && health.state.status === "healthy")
+    return null;
+  const failed = health.identity.status === "unavailable" ? health.identity : health.state.status === "unavailable" ? health.state : null;
+  return failed ? err(failed.error.code, failed.error.message, failed.error.retry) : err("unavailable", "Identity and state links must be healthy before writing.", "after-reconnect");
+}
+function decodeError(value) {
+  const codes = new Set(["unavailable", "unauthenticated", "unsupported", "incompatible", "invalid-input", "not-found", "ambiguous", "stale-owner", "stale-context", "conflict", "cancelled", "disposed", "limit-exceeded", "invalid-operation", "expired"]);
+  const retries = new Set(["never", "after-refresh", "after-reconnect", "same-operation"]);
+  return typeof value === "object" && value !== null && typeof value.code === "string" && codes.has(value.code) && typeof value.message === "string" && typeof value.retry === "string" && retries.has(value.retry) ? ok(value) : err("incompatible", "Malformed state route error.");
+}
+function decodeResult(value, decode) {
+  if (!value || typeof value !== "object" || typeof value.ok !== "boolean")
+    return err("incompatible", "Malformed state route Result.");
+  if (!value.ok) {
+    const failure2 = decodeError(value.error);
+    return failure2.ok ? { ok: false, error: failure2.value } : failure2;
+  }
+  return decode(value.value);
+}
+function createStateTransport(options) {
+  const codecs = stateCodecs(options.resource.definition.codec);
+  const request = async (method, payload, decode, readOptions) => {
+    if (readOptions?.signal?.aborted)
+      return err("cancelled", "State request was cancelled.");
+    try {
+      return decodeResult(await options.connection.request(method, payload, readOptions), decode);
+    } catch {
+      return err("unavailable", "State route request failed.", "after-reconnect");
+    }
+  };
+  return {
+    load(input, readOptions) {
+      return request(identityStateRoutes.load, { address: input.address, expected: input.expected }, codecs.read.decode, readOptions);
+    },
+    async save(input, readOptions) {
+      const normalized = codecs.mutation.decode(structuredClone(codecs.mutation.encode(input)));
+      if (!normalized.ok)
+        return normalized;
+      if (normalized.value.address.pluginId !== options.resource.pluginId || normalized.value.address.collection !== options.resource.definition.collection || normalized.value.schemaVersion !== options.resource.definition.schemaVersion) {
+        return err("invalid-input", "State mutation does not match this resource.");
+      }
+      const unavailable = writeUnavailable(options.connection);
+      if (unavailable)
+        return unavailable;
+      const refreshed = await options.connection.revalidate(readOptions);
+      if (!refreshed.ok)
+        return refreshed;
+      const after = writeUnavailable(options.connection);
+      if (after)
+        return after;
+      const response = await request(identityStateRoutes.save, codecs.mutation.encode(normalized.value), codecs.save.decode, readOptions);
+      if (!response.ok)
+        return response;
+      const outcome = response.value;
+      if (outcome.operationId !== normalized.value.operationId)
+        return err("incompatible", "State route returned a different operation.");
+      if (outcome.status === "indeterminate")
+        return response;
+      const read = "envelope" in outcome ? { status: "present", envelope: outcome.envelope } : outcome.current;
+      const actual = read.status === "present" ? read.envelope.address : read.address;
+      if (actual.instanceId !== normalized.value.address.instanceId || actual.pluginId !== normalized.value.address.pluginId || actual.collection !== normalized.value.address.collection || actual.recordId !== normalized.value.address.recordId || actual.owner !== normalized.value.address.owner || read.status === "present" && read.envelope.schemaVersion !== normalized.value.schemaVersion)
+        return err("incompatible", "State route returned a mismatched resource record.");
+      return response;
+    },
+    reconcile(input, readOptions) {
+      return request(identityStateRoutes.reconcile, { address: input.address, expected: input.expected, operationId: input.operationId }, codecs.lookup.decode, readOptions);
+    },
+    subscribe(address, listener) {
+      return options.connection.subscribe((event) => {
+        if (event.kind !== "state")
+          return;
+        const value = codecs.invalidation.decode(event.event);
+        if (value.ok && value.value.address.instanceId === address.instanceId && value.value.address.pluginId === address.pluginId && value.value.address.collection === address.collection && value.value.address.recordId === address.recordId && value.value.address.owner === address.owner)
+          listener(value.value);
+      });
+    }
+  };
+}
+export {
+  createStateTransport
+};