@stigmer/sdk 3.2.3 → 3.4.0

package/src/gen/datastore.ts

@@ -0,0 +1,381 @@
+// Code generated by stigmer-codegen. DO NOT EDIT.
+
+import { wrapError } from "./errors.js";
+import { stripUndefined } from "./proto-utils.js";
+import { type DeleteResourceInput, type ListParams, type ListResult, type ResourceRef } from "./types.js";
+import { create, fromJson, type JsonValue } from "@bufbuild/protobuf";
+import { ValueSchema } from "@bufbuild/protobuf/wkt";
+import { createClient, type Client, type Transport } from "@connectrpc/connect";
+import { DatastoreSchema, type Datastore } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
+import { DatastoreCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/command_pb";
+import { DatastoreQueryController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/query_pb";
+import { DatastoreRecordCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_command_pb";
+import { InsertRecordRequestSchema, RecordEnvelopeSchema, UpdateRecordRequestSchema, DeleteRecordRequestSchema, FindRecordsRequestSchema, RecordListSchema, DescribeDatastoreRequestSchema, DatastoreDescriptionSchema, type InsertRecordRequest, type RecordEnvelope, type UpdateRecordRequest, type DeleteRecordRequest, type FindRecordsRequest, type RecordList, type DescribeDatastoreRequest, type DatastoreDescription } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_io_pb";
+import { DatastoreRecordQueryController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_query_pb";
+import { DatastoreSpecSchema, FieldType, DatastoreVerb, DatastoreGrantScope, DatastoreRoleSchema, ChannelSenderSubjectSchema, DatastoreSubjectSchema, DatastoreRoleBindingSchema, DatastoreAuthorizationSchema, FieldDeclarationSchema, UniqueWhereSchema, UniqueConstraintSchema, CheckConstraintSchema, ExistsConstraintSchema, DatastoreGrantSchema, CollectionDeclarationSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/spec_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
+import { ApiResourceIdSchema, ApiResourceReferenceSchema, ApiResourceDeleteInputSchema, type UpdateVisibilityInput } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+import { PageInfoSchema } from "@stigmer/protos/ai/stigmer/commons/rpc/pagination_pb";
+import { ApiResourceRefSchema } from "@stigmer/protos/ai/stigmer/iam/iampolicy/v1/spec_pb";
+import { SearchRequestSchema } from "@stigmer/protos/ai/stigmer/search/v1/io_pb";
+import { SearchService } from "@stigmer/protos/ai/stigmer/search/v1/query_pb";
+
+/** Provides operations on datastore resources. */
+export class DatastoreClient {
+  private readonly command: Client<typeof DatastoreCommandController>;
+  private readonly query: Client<typeof DatastoreQueryController>;
+  private readonly datastoreRecordCommand: Client<typeof DatastoreRecordCommandController>;
+  private readonly datastoreRecordQuery: Client<typeof DatastoreRecordQueryController>;
+  private readonly search: Client<typeof SearchService>;
+
+  constructor(transport: Transport) {
+    this.command = createClient(DatastoreCommandController, transport);
+    this.query = createClient(DatastoreQueryController, transport);
+    this.datastoreRecordCommand = createClient(DatastoreRecordCommandController, transport);
+    this.datastoreRecordQuery = createClient(DatastoreRecordQueryController, transport);
+    this.search = createClient(SearchService, transport);
+  }
+
+  async apply(input: DatastoreInput): Promise<Datastore> {
+    try {
+      return await this.command.apply(buildDatastoreProto(input));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async create(input: DatastoreInput): Promise<Datastore> {
+    try {
+      return await this.command.create(buildDatastoreProto(input));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async update(input: DatastoreInput): Promise<Datastore> {
+    try {
+      return await this.command.update(buildDatastoreProto(input));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async updateVisibility(input: UpdateVisibilityInput): Promise<Datastore> {
+    try {
+      return await this.command.updateVisibility(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async delete(input: DeleteResourceInput): Promise<Datastore> {
+    try {
+      return await this.command.delete(create(ApiResourceDeleteInputSchema, {
+        resourceId: input.resourceId,
+        versionMessage: input.versionMessage,
+        force: input.force,
+      }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async get(id: string): Promise<Datastore> {
+    try {
+      return await this.query.get(create(ApiResourceIdSchema, { value: id }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async getByReference(ref: ResourceRef): Promise<Datastore> {
+    try {
+      return await this.query.getByReference(create(ApiResourceReferenceSchema, { ...ref, kind: ApiResourceKind.datastore }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async insertRecord(input: InsertRecordRequest): Promise<RecordEnvelope> {
+    try {
+      return await this.datastoreRecordCommand.insertRecord(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async updateRecord(input: UpdateRecordRequest): Promise<RecordEnvelope> {
+    try {
+      return await this.datastoreRecordCommand.updateRecord(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async deleteRecord(input: DeleteRecordRequest): Promise<RecordEnvelope> {
+    try {
+      return await this.datastoreRecordCommand.deleteRecord(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async findRecords(input: FindRecordsRequest): Promise<RecordList> {
+    try {
+      return await this.datastoreRecordQuery.findRecords(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async describeDatastore(input: DescribeDatastoreRequest): Promise<DatastoreDescription> {
+    try {
+      return await this.datastoreRecordQuery.describeDatastore(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async list(params: ListParams): Promise<ListResult> {
+    try {
+      const resp = await this.search.search(create(SearchRequestSchema, {
+        kinds: [ApiResourceKind.datastore],
+        query: params.query,
+        org: params.org,
+        excludePublic: params.excludePublic ?? false,
+        crossOrgPublic: params.crossOrgPublic ?? false,
+        page: params.page ? create(PageInfoSchema, params.page) : undefined,
+      }));
+      return {
+        entries: resp.entries,
+        totalCount: resp.totalCount,
+        totalPages: resp.totalPages,
+      };
+    } catch (e) { throw wrapError(e); }
+  }
+}
+
+/** Input for creating/updating a Datastore. */
+export interface DatastoreInput {
+  name: string;
+  slug?: string;
+  org: string;
+  labels?: Record<string, string>;
+  visibility?: ApiResourceVisibility;
+  description?: string;
+  timezone?: string;
+  authorization?: DatastoreAuthorizationInput;
+  collections?: CollectionDeclarationInput[];
+}
+
+/** SDK input type for DatastoreAuthorization. */
+export interface DatastoreAuthorizationInput {
+  roles?: DatastoreRoleInput[];
+  bindings?: DatastoreRoleBindingInput[];
+  defaultRole?: string;
+}
+
+/** SDK input type for DatastoreRole. */
+export interface DatastoreRoleInput {
+  name: string;
+}
+
+/** SDK input type for DatastoreRoleBinding. */
+export interface DatastoreRoleBindingInput {
+  subject: DatastoreSubjectInput;
+  role: string;
+}
+
+/** SDK input type for DatastoreSubject. */
+export interface DatastoreSubjectInput {
+  channelSender?: ChannelSenderSubjectInput;
+  principal?: ApiResourceRefInput;
+}
+
+/** SDK input type for ChannelSenderSubject. */
+export interface ChannelSenderSubjectInput {
+  senderKind: string;
+  value: string;
+}
+
+/** SDK input type for ApiResourceRef. */
+export interface ApiResourceRefInput {
+  kind: string;
+  id: string;
+  relation?: string;
+}
+
+/** SDK input type for CollectionDeclaration. */
+export interface CollectionDeclarationInput {
+  name: string;
+  description?: string;
+  fields?: FieldDeclarationInput[];
+  uniques?: UniqueConstraintInput[];
+  checks?: CheckConstraintInput[];
+  exists?: ExistsConstraintInput[];
+  notExists?: ExistsConstraintInput[];
+  grants?: DatastoreGrantInput[];
+}
+
+/** SDK input type for FieldDeclaration. */
+export interface FieldDeclarationInput {
+  name: string;
+  type: FieldType;
+  required?: boolean;
+  default?: JsonValue;
+  enumValues?: string[];
+  description?: string;
+}
+
+/** SDK input type for UniqueConstraint. */
+export interface UniqueConstraintInput {
+  name: string;
+  fields?: string[];
+  where?: UniqueWhereInput;
+  message: string;
+}
+
+/** SDK input type for UniqueWhere. */
+export interface UniqueWhereInput {
+  field: string;
+  equals: JsonValue;
+}
+
+/** SDK input type for CheckConstraint. */
+export interface CheckConstraintInput {
+  name: string;
+  expression: string;
+  when?: string;
+  message: string;
+}
+
+/** SDK input type for ExistsConstraint. */
+export interface ExistsConstraintInput {
+  name: string;
+  collection: string;
+  where: string;
+  when?: string;
+  message: string;
+}
+
+/** SDK input type for DatastoreGrant. */
+export interface DatastoreGrantInput {
+  role: string;
+  verbs?: DatastoreVerb[];
+  scope?: DatastoreGrantScope;
+  readFields?: string[];
+}
+
+function buildDatastoreRoleProto(input: DatastoreRoleInput) {
+  return Object.assign(create(DatastoreRoleSchema), stripUndefined({
+    name: input.name,
+  }));
+}
+
+function buildChannelSenderSubjectProto(input: ChannelSenderSubjectInput) {
+  return Object.assign(create(ChannelSenderSubjectSchema), stripUndefined({
+    senderKind: input.senderKind,
+    value: input.value,
+  }));
+}
+
+function buildApiResourceRefProto(input: ApiResourceRefInput) {
+  return Object.assign(create(ApiResourceRefSchema), stripUndefined({
+    kind: input.kind,
+    id: input.id,
+    relation: input.relation,
+  }));
+}
+
+function buildDatastoreSubjectProto(input: DatastoreSubjectInput) {
+  const msg = create(DatastoreSubjectSchema);
+  if (input.channelSender) {
+    msg.kind = { case: "channelSender", value: buildChannelSenderSubjectProto(input.channelSender) };
+  } else if (input.principal) {
+    msg.kind = { case: "principal", value: buildApiResourceRefProto(input.principal) };
+  }
+  return msg;
+}
+
+function buildDatastoreRoleBindingProto(input: DatastoreRoleBindingInput) {
+  const msg = create(DatastoreRoleBindingSchema);
+  if (input.subject) msg.subject = buildDatastoreSubjectProto(input.subject);
+  if (input.role !== undefined) msg.role = input.role;
+  return msg;
+}
+
+function buildDatastoreAuthorizationProto(input: DatastoreAuthorizationInput) {
+  const msg = create(DatastoreAuthorizationSchema);
+  if (input.roles) msg.roles = input.roles.map(buildDatastoreRoleProto);
+  if (input.bindings) msg.bindings = input.bindings.map(buildDatastoreRoleBindingProto);
+  if (input.defaultRole !== undefined) msg.defaultRole = input.defaultRole;
+  return msg;
+}
+
+function buildFieldDeclarationProto(input: FieldDeclarationInput) {
+  const msg = create(FieldDeclarationSchema);
+  if (input.name !== undefined) msg.name = input.name;
+  if (input.type !== undefined) msg.type = input.type;
+  if (input.required !== undefined) msg.required = input.required;
+  if (input.default !== undefined) msg.default = fromJson(ValueSchema, input.default);
+  if (input.enumValues) msg.enumValues = input.enumValues;
+  if (input.description !== undefined) msg.description = input.description;
+  return msg;
+}
+
+function buildUniqueWhereProto(input: UniqueWhereInput) {
+  const msg = create(UniqueWhereSchema);
+  if (input.field !== undefined) msg.field = input.field;
+  if (input.equals !== undefined) msg.equals = fromJson(ValueSchema, input.equals);
+  return msg;
+}
+
+function buildUniqueConstraintProto(input: UniqueConstraintInput) {
+  const msg = create(UniqueConstraintSchema);
+  if (input.name !== undefined) msg.name = input.name;
+  if (input.fields) msg.fields = input.fields;
+  if (input.where) msg.where = buildUniqueWhereProto(input.where);
+  if (input.message !== undefined) msg.message = input.message;
+  return msg;
+}
+
+function buildCheckConstraintProto(input: CheckConstraintInput) {
+  return Object.assign(create(CheckConstraintSchema), stripUndefined({
+    name: input.name,
+    expression: input.expression,
+    when: input.when,
+    message: input.message,
+  }));
+}
+
+function buildExistsConstraintProto(input: ExistsConstraintInput) {
+  return Object.assign(create(ExistsConstraintSchema), stripUndefined({
+    name: input.name,
+    collection: input.collection,
+    where: input.where,
+    when: input.when,
+    message: input.message,
+  }));
+}
+
+function buildDatastoreGrantProto(input: DatastoreGrantInput) {
+  return Object.assign(create(DatastoreGrantSchema), stripUndefined({
+    role: input.role,
+    verbs: input.verbs,
+    scope: input.scope,
+    readFields: input.readFields,
+  }));
+}
+
+function buildCollectionDeclarationProto(input: CollectionDeclarationInput) {
+  const msg = create(CollectionDeclarationSchema);
+  if (input.name !== undefined) msg.name = input.name;
+  if (input.description !== undefined) msg.description = input.description;
+  if (input.fields) msg.fields = input.fields.map(buildFieldDeclarationProto);
+  if (input.uniques) msg.uniques = input.uniques.map(buildUniqueConstraintProto);
+  if (input.checks) msg.checks = input.checks.map(buildCheckConstraintProto);
+  if (input.exists) msg.exists = input.exists.map(buildExistsConstraintProto);
+  if (input.notExists) msg.notExists = input.notExists.map(buildExistsConstraintProto);
+  if (input.grants) msg.grants = input.grants.map(buildDatastoreGrantProto);
+  return msg;
+}
+
+export function buildDatastoreProto(input: DatastoreInput): Datastore {
+  const authorization = input.authorization ? buildDatastoreAuthorizationProto(input.authorization) : undefined;
+  const collections = input.collections?.map(buildCollectionDeclarationProto);
+  return Object.assign(create(DatastoreSchema), {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Datastore",
+    metadata: Object.assign(create(ApiResourceMetadataSchema), {
+      name: input.name,
+      org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
+      ...(input.visibility && { visibility: input.visibility }),
+    }),
+    spec: Object.assign(create(DatastoreSpecSchema), stripUndefined({
+      description: input.description,
+      timezone: input.timezone,
+      authorization,
+      collections,
+    })),
+  }) as Datastore;
+}

package/src/gen/session.ts

@@ -92,6 +92,7 @@ export interface SessionInput {
   agentInstanceId?: string;
   subject?: string;
   harnessStateId?: string;
+  harnessStateIdHistory?: string[];
   metadata?: Record<string, string>;
   workspaceEntries?: WorkspaceEntryInput[];
   mcpServerUsages?: McpServerUsageInput[];
@@ -208,6 +209,7 @@ export function buildSessionProto(input: SessionInput): Session {
       agentInstanceId: input.agentInstanceId,
       subject: input.subject,
       harnessStateId: input.harnessStateId,
+      harnessStateIdHistory: input.harnessStateIdHistory,
       metadata: input.metadata,
       workspaceEntries,
       mcpServerUsages,

package/src/index.ts

@@ -49,6 +49,7 @@ export {
   getUserMessage,
   type ErrorReason,
   getErrorReason,
+  getRecordConstraint,
   type RpcErrorMetadata,
   annotateRpcError,
   getRpcMetadata,
@@ -93,6 +94,16 @@ export {
   type GetCustomerModelPricingParams,
 } from "./billing.js";
 
+// Cursor accounts client (platform operators only)
+export {
+  CursorAccountsClient,
+  type UpsertCursorAccountParams,
+  type DeleteCursorAccountParams,
+  type AddCursorMemberKeyParams,
+  type RemoveCursorMemberKeyParams,
+  type SetCursorMemberKeyEnabledParams,
+} from "./cursor-accounts.js";
+
 // Search client
 export {
   SearchClient,
@@ -116,6 +127,23 @@ export {
   type ServerInfo,
 } from "./platform.js";
 
+// Manifest engine (kind-agnostic YAML ⇄ proto ⇄ apply)
+export {
+  ManifestClient,
+  parseManifest,
+  serializeManifest,
+  manifestKinds,
+  manifestHandlerForYamlKind,
+  manifestHandlerForTypeName,
+  metadataOf,
+  REDACTED_SECRET_MARKER,
+  containsRedactedSecrets,
+  type AppliedManifest,
+  type ManifestDocument,
+  type ManifestKindHandler,
+  type ParseManifestOptions,
+} from "./manifest/index.js";
+
 // Shared types (from generated code)
 export {
   type DeleteResourceInput,
@@ -130,6 +158,7 @@ export {
 // Re-export all resource client classes and input types
 export {
   AgentClient,
+  buildAgentProto,
   type AgentInput,
   type McpServerUsageInput,
   type ToolApprovalOverrideInput,
@@ -194,6 +223,7 @@ export {
 } from "./gen/oauthapp.js";
 export {
   McpServerClient,
+  buildMcpServerProto,
   type McpServerInput,
   type StdioServerConfigInput,
   type HttpServerConfigInput,
@@ -218,7 +248,12 @@ export {
 } from "./gen/session.js";
 
 // Session utilities (hand-written)
-export { PENDING_SUBJECT, resolvedSubject } from "./session.js";
+export {
+  PENDING_SUBJECT,
+  SESSION_CONTEXT_METADATA_KEY,
+  mergeSessionContext,
+  resolvedSubject,
+} from "./session.js";
 
 // Tool-call view model (framework-agnostic; shared by @stigmer/react and @stigmer/ink)
 export {

package/src/manifest/client.ts

@@ -0,0 +1,145 @@
+// Kind-agnostic apply/lookup over the manifest registry.
+//
+// One client, every registry kind: `apply` drives the kind's command
+// controller with the full resource proto (create-or-update by slug,
+// server-side), `getByReference` loads current server state for
+// create-vs-update previews and YAML editing.
+
+import type { Message } from "@bufbuild/protobuf";
+import { create } from "@bufbuild/protobuf";
+import type { DescService } from "@bufbuild/protobuf";
+import { createClient, type Client, type Transport } from "@connectrpc/connect";
+import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
+import { wrapError } from "../gen/errors.js";
+import { metadataOf, type ManifestDocument } from "./parse.js";
+import {
+  manifestHandlerForYamlKind,
+  manifestKinds,
+  type ManifestKindHandler,
+  type ServiceClientFn,
+} from "./registry.js";
+
+/** Result of applying one manifest document. */
+export interface AppliedManifest {
+  /** The YAML kind that was applied, e.g. `"Agent"`. */
+  readonly yamlKind: string;
+  /** Human-facing kind name, e.g. `"MCP Server"`. */
+  readonly displayName: string;
+  /** Server-authoritative resource name. */
+  readonly name: string;
+  /** Server-authoritative slug (routing key for future applies). */
+  readonly slug: string;
+  /** Organization the resource lives in. */
+  readonly org: string;
+  /** Server-assigned resource id. */
+  readonly id: string;
+  /** The full applied resource, as returned by the server. */
+  readonly message: Message;
+}
+
+/**
+ * Client for applying and loading Stigmer resources as manifests,
+ * independent of kind.
+ *
+ * Complements the typed per-kind clients (`stigmer.agent`, …): those take
+ * curated `*Input` shapes for programmatic use; this one takes full
+ * resource protos produced by {@link parseManifest} — the declarative
+ * "apply this YAML" path, with the same semantics as `stigmer apply -f`.
+ *
+ * @example
+ * ```ts
+ * const docs = parseManifest(yamlText, { org: "acme" });
+ * for (const doc of docs) {
+ *   const applied = await stigmer.manifest.apply(doc);
+ *   console.log(`${applied.displayName} ${applied.slug} applied`);
+ * }
+ * ```
+ */
+export class ManifestClient {
+  // Raw controller clients are created lazily and cached per service —
+  // one dialog session typically touches one or two kinds.
+  private readonly clients = new Map<DescService, Client<DescService>>();
+  private readonly transport: Transport;
+  private readonly clientFor: ServiceClientFn;
+
+  constructor(transport: Transport) {
+    this.transport = transport;
+    this.clientFor = <Desc extends DescService>(service: Desc): Client<Desc> => {
+      let client = this.clients.get(service);
+      if (client === undefined) {
+        client = createClient(service, this.transport);
+        this.clients.set(service, client);
+      }
+      return client as Client<Desc>;
+    };
+  }
+
+  /** The kinds this client can apply, in dependency apply order. */
+  supportedKinds(): readonly ManifestKindHandler[] {
+    return manifestKinds();
+  }
+
+  /**
+   * Apply one parsed manifest document (create-or-update by slug).
+   *
+   * @throws {StigmerError} When the server rejects the apply
+   *   (validation, permissions, …).
+   */
+  async apply(document: ManifestDocument): Promise<AppliedManifest> {
+    let applied: Message;
+    try {
+      applied = await document.handler.apply(this.clientFor, document.message);
+    } catch (e) {
+      throw wrapError(e);
+    }
+
+    const metadata = metadataOf(applied);
+    return {
+      yamlKind: document.handler.yamlKind,
+      displayName: document.handler.displayName,
+      name: metadata?.name || document.name,
+      slug: metadata?.slug || document.slug,
+      org: metadata?.org || document.org,
+      id: metadata?.id ?? "",
+      message: applied,
+    };
+  }
+
+  /**
+   * Load a resource's current server state by kind + org/slug reference.
+   *
+   * @returns The resource proto, or `null` when it does not exist —
+   *   the create-vs-update discriminator for previews.
+   * @throws {Error} When the kind is not in the manifest registry.
+   * @throws {StigmerError} For failures other than not-found.
+   */
+  async getByReference(
+    yamlKind: string,
+    org: string,
+    slug: string,
+  ): Promise<Message | null> {
+    const handler = manifestHandlerForYamlKind(yamlKind);
+    if (handler === undefined) {
+      const supported = manifestKinds()
+        .map((h) => h.yamlKind)
+        .join(", ");
+      throw new Error(
+        `Unsupported resource kind "${yamlKind}". Supported kinds: ${supported}.`,
+      );
+    }
+
+    const ref = create(ApiResourceReferenceSchema, {
+      org,
+      slug,
+      kind: handler.kind,
+    });
+
+    try {
+      return await handler.getByReference(this.clientFor, ref);
+    } catch (e) {
+      const wrapped = wrapError(e);
+      if (wrapped.code === "not-found") return null;
+      throw wrapped;
+    }
+  }
+}

package/src/manifest/index.ts

@@ -0,0 +1,25 @@
+// Manifest engine: kind-agnostic YAML ⇄ proto ⇄ apply for Stigmer resources.
+//
+// The declarative counterpart to the typed per-kind clients — parse a YAML
+// manifest against generated proto schemas, serialize server state back to
+// editable YAML, and apply through each kind's command controller.
+
+export {
+  manifestKinds,
+  manifestHandlerForYamlKind,
+  manifestHandlerForTypeName,
+} from "./registry.js";
+export type { ManifestKindHandler, ServiceClientFn } from "./registry.js";
+
+export { parseManifest, metadataOf } from "./parse.js";
+export type { ManifestDocument, ParseManifestOptions } from "./parse.js";
+
+export { serializeManifest } from "./serialize.js";
+
+export { ManifestClient } from "./client.js";
+export type { AppliedManifest } from "./client.js";
+
+export {
+  REDACTED_SECRET_MARKER,
+  containsRedactedSecrets,
+} from "./redaction.js";