@segmentstream/ontology 0.0.0-stage → 0.92.1

package/dist/render.js

@@ -0,0 +1,512 @@
+import { inputEntities, shortestRoutesFrom } from "./metric-routes.js";
+import { QUERY_METRICS_ROUTE } from "./names.js";
+import { isAllowed, permissionOf, READ_VERB, rolesGranting } from "./permissions.js";
+import { REFERENCE_ANNOTATION } from "./property.js";
+/** What an action of the manifest requires; version 1 manifests leave it implicit. */
+export function actionPermission(entity, action) {
+    return action.permission ?? permissionOf(entity, action.name);
+}
+/** `Requires lead:changeStatus (member, sales).`: the permission and the roles that grant it. */
+function requirement(subject, permission, roles) {
+    const granting = rolesGranting(roles, permission);
+    return granting.length === 0
+        ? `${subject} ${permission}, which no role grants.`
+        : `${subject} ${permission} (${granting.join(", ")}).`;
+}
+const INDENT = "  ";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sentence(text) {
+    return /[.!?]$/.test(text) ? text : `${text}.`;
+}
+function withDescription(head, description) {
+    return description === undefined || description.length === 0 ? head : `${head}: ${description}`;
+}
+function formatValue(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+/** A warehouse-backed property's `unique` is an assertion the platform does not enforce. */
+function propertyLines(input) {
+    const { property, warehouseBacked } = input;
+    const unique = warehouseBacked ? "unique, not enforced" : "unique";
+    const traits = [
+        property.type,
+        ...(property.optional ? ["optional"] : []),
+        ...(property.unique ? [unique] : []),
+        ...(property.default !== undefined ? [`default ${formatValue(property.default)}`] : []),
+        ...(property.min !== undefined ? [`min ${property.min}`] : []),
+        ...(property.max !== undefined ? [`max ${property.max}`] : []),
+        ...(property.maxLength !== undefined ? [`at most ${property.maxLength} characters`] : []),
+        ...(property.managed ? ["changed only through actions"] : []),
+    ];
+    const options = (property.options ?? []).map((option) => option.description.length === 0
+        ? `${option.label} (${option.value})`
+        : `${option.label} (${option.value}) — ${option.description}`);
+    return [
+        withDescription(`${property.name} (${traits.join(", ")})`, property.description),
+        ...options.map((option) => `${INDENT}${option}`),
+    ];
+}
+/**
+ * The inverse of a relationship as its target reads it, including its value-matched join key.
+ */
+function inverseLine(source, relationship) {
+    const { on, phrase, inverse } = relationship;
+    if (on === undefined) {
+        return `${phrase[1]} many ${source.plural} (${inverse})`;
+    }
+    return `${phrase[1]} ${source.plural} (${inverse}), matched on ${on.property}`;
+}
+function relationshipLines(entity, entities, all) {
+    const declared = entity.relationships.map((relationship) => {
+        const { on, phrase, name } = relationship;
+        const target = entities.get(relationship.to);
+        const label = target?.label ?? relationship.to;
+        const optional = relationship.optional === true ? ", optional" : "";
+        let head = `${phrase[0]} one ${label} (${name})${optional}`;
+        if (relationship.cardinality === "many") {
+            head = `${phrase[0]} many ${target?.plural ?? relationship.to} (${name})`;
+        }
+        else if (on !== undefined) {
+            // Value-matched: nothing promises a match, and the key is the declared property pair.
+            const key = `${on.property} = ${label}.${on.targetProperty}`;
+            head = `${phrase[0]} at most one ${label} (${name}), matched on ${key}`;
+        }
+        return withDescription(head, relationship.description);
+    });
+    const inverses = all.flatMap((source) => source.relationships
+        .filter((relationship) => relationship.to === entity.name)
+        .map((relationship) => inverseLine(source, relationship)));
+    return [...declared, ...inverses];
+}
+function inputType(schema) {
+    const reference = schema[REFERENCE_ANNOTATION];
+    if (typeof reference === "string") {
+        return `${reference} id`;
+    }
+    const branches = Array.isArray(schema.anyOf) ? schema.anyOf.filter(isRecord) : [];
+    const values = [
+        ...(Array.isArray(schema.enum) ? schema.enum : []),
+        ...branches.flatMap((branch) => (Array.isArray(branch.enum) ? branch.enum : [])),
+    ];
+    if (values.length > 0) {
+        return `one of ${values.map(formatValue).join(", ")}`;
+    }
+    const formats = {
+        "date-time": "timestamp",
+        uri: "url",
+        uuid: "id",
+    };
+    if (typeof schema.format === "string") {
+        return formats[schema.format] ?? schema.format;
+    }
+    const types = { string: "text", array: "list" };
+    if (typeof schema.type === "string") {
+        return types[schema.type] ?? schema.type;
+    }
+    return typeof schema.$ref === "string" ? "object" : "any JSON value";
+}
+/** Input fields: required ones in declaration order, then optional ones by name. */
+function inputLines(input) {
+    const properties = isRecord(input.properties) ? input.properties : {};
+    const required = Array.isArray(input.required)
+        ? input.required.filter((name) => typeof name === "string")
+        : [];
+    const optional = Object.keys(properties)
+        .filter((name) => !required.includes(name))
+        .sort();
+    return [...required, ...optional].flatMap((name) => {
+        const schema = properties[name];
+        if (!isRecord(schema)) {
+            return [];
+        }
+        const type = required.includes(name) ? inputType(schema) : `optional ${inputType(schema)}`;
+        const description = typeof schema.description === "string" ? schema.description : undefined;
+        return [withDescription(`${name} (${type})`, description)];
+    });
+}
+/** `Calls apollo: Apollo people search. Enriches new leads with company and title.` */
+function connectionLines(action, connections) {
+    return (action.connections ?? []).map((key) => {
+        const description = connections.get(key);
+        return description === undefined || description === ""
+            ? `Calls ${key}.`
+            : `Calls ${key}: ${sentence(description)}`;
+    });
+}
+function actionLines(action, required, connections) {
+    const input = inputLines(action.input);
+    return [
+        `${action.name} — ${action.description}`,
+        ...(required !== undefined ? [`${INDENT}${required}`] : []),
+        ...connectionLines(action, connections).map((line) => `${INDENT}${line}`),
+        ...(input.length > 0
+            ? [`${INDENT}Input:`, ...input.map((line) => `${INDENT}${INDENT}${line}`)]
+            : []),
+    ];
+}
+function section(title, lines) {
+    return lines.length === 0
+        ? []
+        : [`${INDENT}${title}:`, ...lines.map((line) => `${INDENT}${INDENT}${line}`)];
+}
+/** How a condition's operator reads between its property and its value. */
+const CONDITION_OPERATORS = {
+    equals: "=",
+    notEquals: "!=",
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<=",
+    contains: "contains",
+    startsWith: "starts with",
+    endsWith: "ends with",
+};
+function literal(value) {
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+/** `status = "won"`, `status in ("won", "invoiced")`, `amount >= 100`, `name contains "x"`. */
+function conditionText(condition, property) {
+    const { operator, value } = condition;
+    const values = Array.isArray(condition.values) ? condition.values : [];
+    const list = `(${values.map(literal).join(", ")})`;
+    switch (operator) {
+        case "in":
+            return `${property} in ${list}`;
+        case "notIn":
+            return `${property} not in ${list}`;
+        case "isNull":
+            return `${property} is null`;
+        case "isNotNull":
+            return `${property} is not null`;
+        case "between":
+            return `${property} between ${literal(values[0])} and ${literal(values[1])}`;
+        default: {
+            const symbol = CONDITION_OPERATORS[String(operator)] ?? String(operator);
+            return value === undefined
+                ? `${property} ${symbol}`
+                : `${property} ${symbol} ${literal(value)}`;
+        }
+    }
+}
+/** How an aggregate reads in a sentence: `count`, `sum of amount`. */
+const AGGREGATE_NAMES = {
+    count: "count",
+    sum: "sum",
+    countDistinct: "distinct count",
+    avg: "average",
+    min: "minimum",
+    max: "maximum",
+};
+/**
+ * Every aggregate a metric reads: its own, top-level or inside arithmetic, and those of the
+ * metrics it references, followed once each.
+ */
+function readAggregates(entity, metric) {
+    const found = [];
+    const visited = new Set();
+    const visit = (expression, where, depth) => {
+        if (!isRecord(expression) || depth > 30) {
+            return;
+        }
+        const args = Array.isArray(expression.args) ? expression.args : [];
+        const name = AGGREGATE_NAMES[String(expression.op)];
+        if (expression.op === "filtered" && Array.isArray(expression.where)) {
+            const conditions = expression.where.filter(isRecord);
+            args.forEach((arg) => visit(arg, conditions, depth + 1));
+        }
+        else if (expression.op === "metric") {
+            const referenced = entity.metrics?.find((other) => other.name === expression.name);
+            if (referenced !== undefined && !visited.has(referenced.name)) {
+                visited.add(referenced.name);
+                visit(referenced.expression, undefined, depth + 1);
+            }
+        }
+        else if (name !== undefined) {
+            const [argument] = args;
+            const column = isRecord(argument) && argument.op === "column" ? argument.name : undefined;
+            found.push({ name, column, where });
+        }
+        else {
+            args.forEach((arg) => visit(arg, where, depth + 1));
+        }
+    };
+    visited.add(metric.name);
+    visit(metric.expression, undefined, 0);
+    return found;
+}
+/**
+ * The columns a metric is a balance over: its own `balanceOver`, and that of every metric its
+ * expression references, since an expression is a balance when any metric it reads is.
+ */
+function balanceColumns(entity, metric) {
+    const columns = new Set();
+    const visited = new Set();
+    const visit = (candidate) => {
+        if (visited.has(candidate.name)) {
+            return;
+        }
+        visited.add(candidate.name);
+        if (candidate.balanceOver !== undefined) {
+            columns.add(candidate.balanceOver);
+        }
+        for (const name of referencedMetrics(candidate.expression)) {
+            const referenced = entity.metrics?.find((other) => other.name === name);
+            if (referenced !== undefined) {
+                visit(referenced);
+            }
+        }
+    };
+    visit(metric);
+    return [...columns];
+}
+function referencedMetrics(expression) {
+    if (!isRecord(expression)) {
+        return [];
+    }
+    if (expression.op === "metric" && typeof expression.name === "string") {
+        return [expression.name];
+    }
+    return Array.isArray(expression.args) ? expression.args.flatMap(referencedMetrics) : [];
+}
+/**
+ * What a metric's definition adds to its description: the conditions its aggregates read rows by,
+ * and the property a balance must be grouped by or filtered to one day of. `Where …` only when every
+ * aggregate it reads, references followed, has the same conditions; otherwise a sentence per
+ * restricted aggregate. Columns read as the properties that map them, the names requests use.
+ */
+function metricNotes(entity, metric) {
+    const propertyOf = (column) => entity.properties.find((property) => (property.column ?? property.name) === column)?.name ??
+        String(column);
+    const aggregates = readAggregates(entity, metric).map(({ name, column, where }) => ({
+        name: column === undefined ? name : `${name} of ${propertyOf(column)}`,
+        conditions: where
+            ?.map((condition) => conditionText(condition, propertyOf(condition.column)))
+            .join(" and "),
+    }));
+    const conditions = aggregates.map((aggregate) => aggregate.conditions);
+    const [first] = conditions;
+    const balances = balanceColumns(entity, metric).map((column) => `Balance over ${propertyOf(column)}: group by it or filter it to one day.`);
+    // "Where" holds only when every aggregate, references followed, reads by the same condition.
+    if (first !== undefined && conditions.every((candidate) => candidate === first)) {
+        return [`Where ${first}.`, ...balances];
+    }
+    const restricted = aggregates.flatMap(({ name, conditions: text }) => text === undefined ? [] : [`Its ${name} reads rows where ${text}.`]);
+    return [...new Set(restricted), ...balances];
+}
+/**
+ * A metric's description followed by its conditions and balance note, as `describe`, the MCP
+ * metric list and the console show it: `Revenue of won orders. Where status = "won".`
+ */
+export function metricDescription(entity, metric) {
+    const notes = metricNotes(entity, metric);
+    if (notes.length === 0) {
+        return metric.description;
+    }
+    const described = metric.description === "" ? [] : [sentence(metric.description)];
+    return [...described, ...notes].join(" ");
+}
+function renderEntity(entity, manifest, entities, options) {
+    const reader = options.as;
+    const actions = entity.actions.filter((action) => reader === undefined ||
+        isAllowed(actionPermission(entity.name, action), { permissions: reader }));
+    const read = entity.permissions?.read ?? permissionOf(entity.name, READ_VERB);
+    const connections = new Map((manifest.connections ?? []).map((connection) => [connection.key, connection.description]));
+    return [
+        `${entity.label} (${entity.plural.toLowerCase()}): ${entity.description}`,
+        `${INDENT}Identified by: ${entity.title}.`,
+        ...(reader === undefined
+            ? [`${INDENT}${requirement("Reading requires", read, manifest.roles)}`]
+            : []),
+        ...(entity.source
+            ? [`${INDENT}Source: ${entity.source.asset}; key: ${entity.source.key.join(", ")}.`]
+            : []),
+        ...section("Properties", entity.properties.flatMap((property) => propertyLines({ property, warehouseBacked: entity.source !== undefined }))),
+        ...section("Metrics", (entity.metrics ?? []).map((metric) => `${metric.name}: ${metricDescription(entity, metric)} (${metric.unit}).`)),
+        ...section("Relationships", relationshipLines(entity, entities, manifest.entities)),
+        ...section(reader === undefined ? "Actions" : "Actions you may run", actions.flatMap((action) => actionLines(action, reader === undefined
+            ? requirement("Requires", actionPermission(entity.name, action), manifest.roles)
+            : undefined, connections))),
+    ].join("\n");
+}
+function renderRoles(roles) {
+    return [
+        "Roles:",
+        ...roles.flatMap((role) => [
+            `${INDENT}${role.name} — ${sentence(role.description)}`,
+            ...(role.permissions === undefined
+                ? []
+                : [
+                    `${INDENT}${INDENT}Permissions: ${role.permissions.length === 0 ? "none" : role.permissions.join(", ")}.`,
+                ]),
+            ...(role.scopes ?? []).map((scope) => `${INDENT}${INDENT}Scoped: ${scope.permission} where ${JSON.stringify(scope.where)}.`),
+        ]),
+    ].join("\n");
+}
+/**
+ * Renders the catalog as prose for agents and people: each entity with its properties, both
+ * directions of its relationships and its actions, then the roles with their permissions and the
+ * `where`, in wire form, of each scoped one. Without a reader, each action and each entity's reads
+ * say which permission they require and which roles grant it; with one, only the actions the reader
+ * may run are listed. A pure function of the manifest, so the console, the CLI and the service
+ * describe the same ontology.
+ */
+export function renderCatalog(manifest, options = {}) {
+    const entities = new Map(manifest.entities.map((entity) => [entity.name, entity]));
+    const sections = manifest.entities
+        .filter((entity) => entity.source === undefined ||
+        options.as === undefined ||
+        isAllowed(entity.permissions?.read ?? `${entity.name}:read`, { permissions: options.as }))
+        .map((entity) => renderEntity(entity, manifest, entities, options));
+    if (manifest.feedback !== undefined) {
+        sections.unshift(`Feedback: ${manifest.feedback.enabled ? "enabled" : "disabled"}; ` +
+            `files: ${manifest.feedback.files ? "enabled" : "disabled"} (explicit setting or another non-feedback blob); ` +
+            `builders: ${manifest.feedback.builders.join(", ") || "none"}.`);
+    }
+    const metricQueries = renderMetricQueries(manifest, options.as);
+    const parts = [
+        ...sections,
+        renderRoles(manifest.roles),
+        ...(metricQueries === "" ? [] : [metricQueries]),
+    ];
+    return `${parts.join("\n\n")}\n`;
+}
+/**
+ * The catalog as `describe` answers a reader: {@link renderCatalog} with the reader's permissions,
+ * or everything without them.
+ */
+export function describeCatalog(manifest, permissions) {
+    return renderCatalog(manifest, permissions === undefined ? {} : { as: permissions });
+}
+/**
+ * The rule every surface repeats (docs/ontology-aggregates-spec.md, "Three ways to ask"), naming
+ * the tool that computes metrics.
+ */
+export const RECORDS_OR_METRIC_QUERIES = "look at or change records through find and actions; count, sum or compare through query_metrics";
+/** Whether the reader may read the entity; without a reader, everything is described. */
+function readable(entity, permissions) {
+    return permissions === undefined || isAllowed(permissionOf(entity, READ_VERB), { permissions });
+}
+/**
+ * Every metric of the entities the reader may read, warehouse-backed and stored alike, in
+ * declaration order. Without permissions, every metric.
+ */
+export function metricsFor(manifest, permissions) {
+    return manifest.entities
+        .filter((entity) => readable(entity.name, permissions))
+        .flatMap((entity) => (entity.metrics ?? []).map((metric) => ({
+        name: `${entity.name}.${metric.name}`,
+        entity,
+        metric,
+    })));
+}
+/**
+ * The metrics of the model whose every input entity the reader may read, in declaration order.
+ * Reading a model metric is reading its inputs. Without permissions, every one.
+ */
+export function modelMetricsFor(manifest, permissions) {
+    return (manifest.metrics ?? []).filter((metric) => inputEntities(metric).every((entity) => readable(entity, permissions)));
+}
+/** `a`, `a and b`, `a, b and c`. */
+function listed(values) {
+    return values.length < 2
+        ? values.join("")
+        : `${values.slice(0, -1).join(", ")} and ${values[values.length - 1]}`;
+}
+/**
+ * How one alignment group reads: `sales.order_date aligns with plans.month`, and for an entity
+ * without a counterpart `listings has no counterpart for sales.order_date`. Members follow the
+ * metric's input entities, whatever order the document keeps them in.
+ */
+function alignmentClauses(metric, group) {
+    const order = inputEntities(metric);
+    const members = Object.entries(group).sort(([left], [right]) => order.indexOf(left) - order.indexOf(right));
+    const present = members.flatMap(([entity, property]) => property === null ? [] : [`${entity}.${property}`]);
+    const absent = members.flatMap(([entity, property]) => (property === null ? [entity] : []));
+    const [first, ...rest] = present;
+    if (first === undefined) {
+        return [];
+    }
+    return [
+        ...(rest.length > 0 ? [`${first} aligns with ${listed(rest)}`] : []),
+        ...absent.map((entity) => `${entity} has no counterpart for ${first}`),
+    ];
+}
+/**
+ * A metric of the model as `describe`, the MCP tool and the instructions show it: its description,
+ * the entity metrics it reads and how their properties align. `Ordered over planned units. Reads
+ * sales.ordered and plans.planned_units; sales.order_date aligns with plans.month.`
+ */
+export function modelMetricDescription(metric) {
+    const clauses = [
+        `Reads ${listed(metric.inputs)}`,
+        ...metric.align.flatMap((group) => alignmentClauses(metric, group)),
+    ];
+    const described = metric.description === "" ? [] : [sentence(metric.description)];
+    return [...described, `${clauses.join("; ")}.`].join(" ");
+}
+/**
+ * The entities one entity reaches, with the shortest routes to each: exactly the routes metric query
+ * resolution weighs ({@link shortestRoutesFrom}). Only then is the reader applied: a target they may
+ * not read is left out, and so is any route through an entity they may not read, which the service
+ * would refuse. A target keeps `ambiguous` from before that filter, so a route is never shown as the
+ * only one when the resolver would ask for it to be written.
+ */
+export function reachesOf(manifest, from, permissions) {
+    return [...shortestRoutesFrom(manifest, from)].flatMap(([target, routes]) => {
+        const followed = routes.filter((route) => route.entities.every((entity) => readable(entity, permissions)));
+        return followed.length === 0
+            ? []
+            : [
+                {
+                    target,
+                    routes: followed.map((route) => route.relationships.join(".")),
+                    ambiguous: routes.length > 1,
+                },
+            ];
+    });
+}
+/** `sales reaches product (product), region (product.region or listing.region; write the route).` */
+function reachLine(entity, reaches) {
+    const targets = reaches.map(({ target, routes, ambiguous }) => `${target} (${routes.join(" or ")}${ambiguous ? "; write the route" : ""})`);
+    return `${entity} reaches ${targets.join(", ")}.`;
+}
+/**
+ * The metric query part of the catalog's prose: every metric the reader may read, model-wide, the
+ * metrics of the model whose every input they may read, and per metric entity the entities it
+ * reaches. Empty when the reader may read no metric.
+ */
+export function renderMetricQueries(manifest, permissions) {
+    const metrics = metricsFor(manifest, permissions);
+    if (metrics.length === 0) {
+        return "";
+    }
+    const owners = [...new Set(metrics.map(({ entity }) => entity.name))];
+    const reachLines = owners.flatMap((owner) => {
+        const reaches = reachesOf(manifest, owner, permissions);
+        return reaches.length === 0 ? [] : [reachLine(owner, reaches)];
+    });
+    const metricLines = metrics.map(({ name, entity, metric }) => `${name} (${metric.unit}): ${sentence(metricDescription(entity, metric))}`);
+    const modelLines = modelMetricsFor(manifest, permissions).map((metric) => `${metric.name} (${metric.unit}): ${modelMetricDescription(metric)}`);
+    return [
+        `Metric queries: ${RECORDS_OR_METRIC_QUERIES} (POST /api/ontology/${QUERY_METRICS_ROUTE}, or the ` +
+            "query_metrics tool).",
+        `${INDENT}Metrics, as <entity>.<metric>:`,
+        ...metricLines.map((line) => `${INDENT}${INDENT}${line}`),
+        ...(modelLines.length === 0
+            ? []
+            : [
+                `${INDENT}Metrics of the model, by name:`,
+                ...modelLines.map((line) => `${INDENT}${INDENT}${line}`),
+            ]),
+        ...(reachLines.length === 0
+            ? []
+            : [
+                `${INDENT}Group and filter by <entity>.<property>. Where a target says write the route, ` +
+                    "name it from the metric's entity: <entity>.<relationship>.<property>. Through " +
+                    "to-one relationships:",
+                ...reachLines.map((line) => `${INDENT}${INDENT}${line}`),
+            ]),
+    ].join("\n");
+}

package/dist/replication/baseline.d.ts

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import type { OntologyManifest } from "../manifest.js";
+import { type ReplicationFills, type ReplicationSelection, type ReplicationExclusion } from "./model.js";
+import type { ReplicationLineage } from "./lineage.js";
+export interface ReplicationTarget {
+    readonly generation: string;
+    readonly source_id: string;
+    readonly from_revision: string;
+    readonly manifest: OntologyManifest;
+    readonly selection: ReadonlyArray<ReplicationSelection>;
+    readonly protocol?: number;
+    readonly schema_version?: number;
+    readonly lineage?: ReplicationLineage | null;
+    readonly identities?: import("./identities.js").ReplicationIdentities | null;
+    readonly scans_complete?: boolean;
+    readonly backfill_sources?: ReadonlyArray<{
+        readonly table: string | null;
+        readonly skip?: boolean;
+    }>;
+    readonly baseline_complete?: boolean;
+    readonly backfill_complete?: boolean;
+    readonly initial_revision?: string | null;
+    readonly replay_complete?: boolean;
+    readonly fills?: ReplicationFills;
+}
+declare const ReplicationBaselineFailed_base: Schema.Class<ReplicationBaselineFailed, Schema.TaggedStruct<"ReplicationBaselineFailed", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/** An initial scan cannot be created with the requested state or record projection. */
+export declare class ReplicationBaselineFailed extends ReplicationBaselineFailed_base {
+}
+interface BaselineInput {
+    readonly generation: string;
+    readonly manifest: OntologyManifest;
+    readonly exclusions?: ReadonlyArray<ReplicationExclusion>;
+    readonly selection: ReadonlyArray<ReplicationSelection>;
+    readonly newSource?: boolean;
+}
+/** Enable capture in a short fenced transaction before scanning any business records. */
+export declare const prepareReplicationBaseline: (sql: SqlClient.SqlClient, input: BaselineInput) => Effect.Effect<ReplicationTarget, import("effect/unstable/sql/SqlError").SqlError | ReplicationBaselineFailed, never>;
+/**
+ * Commit one keyset page and its cursor together. Schema 5 locks source rows before allocating
+ * snapshot revisions; older schemas retain their revision-zero baseline protocol. A failed page
+ * retries without changing earlier pages, and capture covers inserts/deletes across pages.
+ */
+export declare const advanceReplicationBaseline: (sql: SqlClient.SqlClient, generation: string) => Effect.Effect<ReplicationTarget, import("effect/unstable/sql/SqlError").SqlError | ReplicationBaselineFailed, never>;
+/** Prepare once, then advance a bounded page; subsequent calls resume the same durable target. */
+export declare const createReplicationBaseline: (sql: SqlClient.SqlClient, input: BaselineInput) => Effect.Effect<ReplicationTarget, import("effect/unstable/sql/SqlError").SqlError | ReplicationBaselineFailed, never>;
+export {};