@segmentstream/ontology 0.0.0-stage → 0.92.1

package/dist/replication/migrate.js

@@ -0,0 +1,84 @@
+import { Effect } from "effect";
+import { quoteIdentifier as qi, tableName } from "../migrate/storage.js";
+import { renamedReplicationField } from "./lineage.js";
+import { queryFields } from "../query.js";
+import { snapshotExpression } from "./schema.js";
+/** Persist exclusions across temporary removals, and follow a property's logical rename. */
+export function migrationReplicationExclusions(current, target, exclusions) {
+    return exclusions.map((item) => ({
+        ...item,
+        ...(item.fields === undefined
+            ? {}
+            : {
+                fields: item.fields.map((field) => {
+                    const entity = target.entities.find((entity) => entity.id === item.entityId);
+                    const renamed = entity?.properties.find((property) => renamedReplicationField(current, target, item.entityId, property.name) === field);
+                    return renamed?.name ?? field;
+                }),
+            }),
+    }));
+}
+/** Only current declarations participate; retained exclusions still protect a later restoration. */
+export function effectiveReplicationExclusions(manifest, exclusions) {
+    return exclusions.flatMap((item) => {
+        const entity = manifest.entities.find((entity) => entity.id === item.entityId && !entity.builtIn && !entity.source);
+        if (!entity) {
+            return [];
+        }
+        const fields = new Set(queryFields(entity).map((field) => field.name));
+        const relationships = new Set(entity.relationships.map((relationship) => relationship.name));
+        return [
+            {
+                ...item,
+                ...(item.fields === undefined
+                    ? {}
+                    : { fields: item.fields.filter((field) => fields.has(field)) }),
+                ...(item.relationships === undefined
+                    ? {}
+                    : { relationships: item.relationships.filter((name) => relationships.has(name)) }),
+            },
+        ];
+    });
+}
+/**
+ * Fills of the migrated target, read inside the migration transaction after its steps. PostgreSQL gives
+ * a field added to an existing entity one value on every row, so any row shows it as capture would
+ * serialize it. A null value needs no fill: a missing key already reads as null.
+ */
+export const migratedReplicationFills = (sql, current, manifest, selection, retained) => Effect.gen(function* () {
+    const fills = {};
+    for (const next of selection) {
+        const entity = manifest.entities.find((item) => item.id === next.entityId);
+        const previousEntity = current.manifest.entities.find((item) => item.id === entity.id);
+        const values = {};
+        const previousFills = current.fills?.[entity.id] ?? {};
+        for (const field of next.fields) {
+            const old = renamedReplicationField(current.manifest, manifest, entity.id, field) ?? field;
+            if (Object.hasOwn(previousFills, old)) {
+                values[field] = previousFills[old];
+            }
+        }
+        if (previousEntity) {
+            const previousFields = new Set(queryFields(previousEntity).map((field) => field.name));
+            const kept = retained?.entities.find((item) => item.id === entity.id);
+            const added = next.fields.filter((field) => !previousFields.has(field) &&
+                !renamedReplicationField(current.manifest, manifest, entity.id, field) &&
+                !kept?.fields.properties.some((property) => property.name === field) &&
+                !kept?.fields.relationships.some((relationship) => `${relationship.name}_id` === field));
+            if (added.length > 0) {
+                const [row] = yield* sql.unsafe(`SELECT ${snapshotExpression(entity, "record")} AS snapshot
+             FROM ${qi(tableName(entity.name))} AS record LIMIT 1`);
+                for (const field of added) {
+                    const value = row?.snapshot[field];
+                    if (value !== undefined && value !== null) {
+                        values[field] = value;
+                    }
+                }
+            }
+        }
+        if (Object.keys(values).length > 0) {
+            fills[entity.id] = values;
+        }
+    }
+    return fills;
+});

package/dist/replication/model.d.ts

@@ -0,0 +1,52 @@
+import { type OntologyManifest } from "../manifest.js";
+/** The current projection of a continuous replication stream. `id` is always included. */
+export interface ReplicationSelection {
+    readonly entityId: string;
+    readonly fields: ReadonlyArray<string>;
+    readonly relationships?: ReadonlyArray<string>;
+}
+/**
+ * By entity ID, the captured value of each field added to an already replicated entity. Events
+ * captured before the field existed lack its key, while every record they describe holds this value.
+ */
+export type ReplicationFills = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+/** Everything is replicated unless explicitly excluded. Internal identity data is never exported. */
+export interface ReplicationExclusion {
+    readonly entityId: string;
+    readonly disabled?: boolean;
+    readonly fields?: ReadonlyArray<string>;
+    readonly relationships?: ReadonlyArray<string>;
+}
+export declare function resolveReplicationSelection(manifest: OntologyManifest, exclusions?: ReadonlyArray<ReplicationExclusion>): ReadonlyArray<ReplicationSelection>;
+export interface ReplicationEvent {
+    readonly event_id: string;
+    readonly source_id: string;
+    readonly generation: string;
+    readonly entity_id: string;
+    readonly record_key: string;
+    readonly record_kind: string;
+    /** Decimal strings preserve PostgreSQL bigint precision in JavaScript. */
+    readonly revision: string;
+    readonly deleted: boolean;
+    readonly schema_hash: string;
+    /** Pub/Sub's BigQuery table-schema mode expects a string for a JSON column. */
+    readonly payload: string;
+}
+export declare const REPLICATION_BATCH_SIZE = 100;
+export declare const REPLICATION_BATCH_BYTES = 1000000;
+export declare const REPLICATION_RECORD_BYTES = 200000;
+export declare function validateReplicationSelection(manifest: OntologyManifest, selection: ReadonlyArray<ReplicationSelection>): void;
+export declare function replicationEventId(source: string, history: string, generation: string): string;
+/** Includes base64 and JSON overhead, not just the original payload bytes. */
+export declare function publishMessage(event: ReplicationEvent): {
+    data: string;
+};
+/** Immutable warehouse provenance. Current workspace admission is independently required. */
+export interface SourcePublicationProof {
+    readonly published: string;
+    readonly sourceId: string;
+    readonly selectorIncarnation: string;
+    readonly registryIncarnation: string;
+    readonly projectId: string;
+    readonly workspaceId: string;
+}

package/dist/replication/model.js

@@ -0,0 +1,99 @@
+import { createHash } from "node:crypto";
+import { isValueMatched } from "../manifest.js";
+import { queryFields } from "../query.js";
+export function resolveReplicationSelection(manifest, exclusions = []) {
+    const entities = manifest.entities.filter((entity) => !entity.builtIn && !entity.source);
+    if (new Set(exclusions.map((item) => item.entityId)).size !== exclusions.length) {
+        throw new Error("Replication exclusions must name distinct entities.");
+    }
+    for (const item of exclusions) {
+        const entity = entities.find((candidate) => candidate.id === item.entityId);
+        if (!entity) {
+            throw new Error(`Unknown stored business entity in replication exclusions: ${item.entityId}.`);
+        }
+        const fields = new Set(queryFields(entity).map((field) => field.name));
+        const relationships = new Set(entity.relationships.map((relationship) => relationship.name));
+        if (item.fields?.some((field) => field === "id" || !fields.has(field))) {
+            throw new Error(`Unknown or required replication field on ${entity.name}.`);
+        }
+        if (item.relationships?.some((relationship) => !relationships.has(relationship))) {
+            throw new Error(`Unknown replication relationship on ${entity.name}.`);
+        }
+        // A value-matched relationship has no `<name>_id`: its reference is the property `on` names.
+        const matched = entity.relationships.find((relationship) => item.relationships?.includes(relationship.name) && isValueMatched(relationship));
+        if (matched !== undefined) {
+            throw new Error(`${entity.name}.${matched.name} is matched by value; exclude its property ` +
+                `${matched.on?.property ?? ""} instead.`);
+        }
+    }
+    const included = entities.filter((entity) => !exclusions.some((item) => item.entityId === entity.id && item.disabled));
+    const selection = included.map((entity) => {
+        const excluded = exclusions.find((item) => item.entityId === entity.id);
+        const keyed = entity.relationships.filter((relationship) => relationship.cardinality === "one" && !isValueMatched(relationship));
+        const excludedFields = new Set([
+            ...(excluded?.fields ?? []),
+            ...keyed
+                .filter((relationship) => excluded?.relationships?.includes(relationship.name))
+                .map((relationship) => `${relationship.name}_id`),
+        ]);
+        return {
+            entityId: entity.id,
+            fields: queryFields(entity)
+                .filter((field) => !excludedFields.has(field.name))
+                .map((field) => field.name),
+            relationships: entity.relationships
+                .filter((relationship) => relationship.cardinality === "many" &&
+                !excluded?.relationships?.includes(relationship.name) &&
+                included.some((target) => target.name === relationship.to))
+                .map((relationship) => relationship.name),
+        };
+    });
+    validateReplicationSelection(manifest, selection);
+    return selection;
+}
+export const REPLICATION_BATCH_SIZE = 100;
+export const REPLICATION_BATCH_BYTES = 1_000_000;
+// Leaves room for JSON escaping, the envelope and base64 inside a 1 MB publish request.
+export const REPLICATION_RECORD_BYTES = 200_000;
+export function validateReplicationSelection(manifest, selection) {
+    if (new Set(selection.map((s) => s.entityId)).size !== selection.length) {
+        throw new Error("Replicated entities must be distinct.");
+    }
+    const viewNames = new Set();
+    const addView = (name) => {
+        const key = name.toLowerCase();
+        if (viewNames.has(key)) {
+            throw new Error("Replicated entity and relationship view names collide.");
+        }
+        viewNames.add(key);
+    };
+    for (const item of selection) {
+        const entity = manifest.entities.find((e) => e.id === item.entityId);
+        if (!entity || entity.builtIn || entity.source !== undefined) {
+            throw new Error(`Only stored business entities can be replicated: ${item.entityId}.`);
+        }
+        addView(entity.name);
+        const fields = new Set(queryFields(entity).map((f) => f.name));
+        if (item.fields.some((field) => !fields.has(field))) {
+            throw new Error(`Unknown replication field on ${entity.name}.`);
+        }
+        for (const name of item.relationships ?? []) {
+            const relationship = entity.relationships.find((r) => r.name === name);
+            const target = manifest.entities.find((e) => e.name === relationship?.to);
+            if (relationship?.cardinality !== "many" ||
+                !target ||
+                target.builtIn ||
+                !selection.some((s) => s.entityId === target.id)) {
+                throw new Error(`Replication of ${entity.name}.${name} requires both business entities.`);
+            }
+            addView(`${entity.name}_${name}`);
+        }
+    }
+}
+export function replicationEventId(source, history, generation) {
+    return createHash("sha256").update(`${source}:${history}:${generation}`).digest("hex");
+}
+/** Includes base64 and JSON overhead, not just the original payload bytes. */
+export function publishMessage(event) {
+    return { data: Buffer.from(JSON.stringify(event)).toString("base64") };
+}

package/dist/replication/scans.d.ts

@@ -0,0 +1,34 @@
+import { Effect } from "effect";
+import type { SqlClient } from "effect/unstable/sql";
+import type { ReplicationTarget } from "./baseline.js";
+import { ReplicationBaselineFailed } from "./baseline.js";
+export interface ReplicationScanScope {
+    readonly entityId: string;
+    readonly kind: string;
+}
+export declare function replicationScanScopes(target: Pick<ReplicationTarget, "selection">): ReplicationScanScope[];
+/** Installed in a lifecycle transaction. Existing cursors survive unrelated schema changes. */
+export declare const scheduleReplicationScans: (sql: SqlClient.SqlClient, generation: string, scopes: readonly ReplicationScanScope[], options?: {
+    readonly initial?: boolean;
+    readonly reset?: boolean;
+}) => Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, never>;
+/** Convert an old positional baseline once, before its manifest can change. */
+export declare const upgradeReplicationScans: (sql: SqlClient.SqlClient, target: ReplicationTarget & {
+    readonly baseline_cursor?: {
+        readonly index?: number;
+        readonly key?: string;
+    };
+}) => Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, never>;
+/** Drop obsolete scopes without making an unrelated pending scan start over. */
+export declare const reconcileReplicationScans: (sql: SqlClient.SqlClient, target: ReplicationTarget) => import("effect/unstable/sql/Statement").Statement<object>;
+/**
+ * Full snapshots of one affected entity/edge scope. Share lifecycle admission first, then lock
+ * source rows in key order before allocating revisions. Concurrent mutations therefore supersede
+ * these snapshots, including deletes, without holding a business lock for the whole copy.
+ */
+export declare const advanceReplicationScan: (sql: SqlClient.SqlClient, generation: string) => Effect.Effect<{
+    complete: boolean;
+    progressed: boolean;
+}, import("effect/unstable/sql/SqlError").SqlError | ReplicationBaselineFailed, never>;
+/** A published schema may add coverage only after its finite scan output is accepted by Pub/Sub. */
+export declare const replicationScansReady: (sql: SqlClient.SqlClient, generation: string) => Effect.Effect<boolean, import("effect/unstable/sql/SqlError").SqlError, never>;

package/dist/replication/scans.js

@@ -0,0 +1,158 @@
+import { Effect } from "effect";
+import { ReplicationBaselineFailed } from "./baseline.js";
+import { joinColumnNames, joinTableName, quoteIdentifier as qi, quoteLiteral as ql, tableName, } from "../migrate/storage.js";
+import { REPLICATION_RECORD_BYTES } from "./model.js";
+import { snapshotExpression } from "./schema.js";
+import { lockReplicationLifecycle, shareReplicationLifecycle } from "./transaction.js";
+export function replicationScanScopes(target) {
+    return target.selection.flatMap((item) => [
+        { entityId: item.entityId, kind: "entity" },
+        ...(item.relationships ?? []).map((name) => ({
+            entityId: item.entityId,
+            kind: `edge:${name}`,
+        })),
+    ]);
+}
+/** Installed in a lifecycle transaction. Existing cursors survive unrelated schema changes. */
+export const scheduleReplicationScans = (sql, generation, scopes, options = {}) => Effect.gen(function* () {
+    for (const scope of scopes) {
+        yield* sql.unsafe(`INSERT INTO _ontology_replication_scans (generation, entity_id, record_kind, initial)
+       VALUES ($1::uuid,$2,$3,$4)
+       ON CONFLICT (generation,entity_id,record_kind) WHERE NOT complete DO UPDATE
+         SET cursor = CASE WHEN $5::boolean THEN '' ELSE _ontology_replication_scans.cursor END,
+           required = true, initial = _ontology_replication_scans.initial OR excluded.initial`, [generation, scope.entityId, scope.kind, options.initial ?? false, options.reset ?? false]);
+    }
+    if (scopes.length > 0) {
+        yield* sql.unsafe("UPDATE _ontology_replication_targets SET scans_complete = false WHERE generation = $1::uuid", [generation]);
+    }
+});
+/** Convert an old positional baseline once, before its manifest can change. */
+export const upgradeReplicationScans = (sql, target) => Effect.gen(function* () {
+    const [existing] = yield* sql.unsafe("SELECT EXISTS (SELECT 1 FROM _ontology_replication_scans WHERE generation = $1::uuid) AS present", [target.generation]);
+    if (target.baseline_complete !== false || existing?.present) {
+        return;
+    }
+    const position = target.baseline_cursor?.index ?? 0;
+    const scopes = replicationScanScopes(target).slice(position);
+    // An empty remaining scope list still needs to finalize the fixed initialization fence.
+    yield* sql.unsafe("UPDATE _ontology_replication_targets SET scans_complete = false WHERE generation = $1::uuid", [target.generation]);
+    yield* scheduleReplicationScans(sql, target.generation, scopes, { initial: true });
+    if (scopes[0] && target.baseline_cursor?.key) {
+        yield* sql.unsafe(`UPDATE _ontology_replication_scans SET cursor = $4
+      WHERE generation = $1::uuid AND entity_id = $2 AND record_kind = $3 AND NOT complete`, [target.generation, scopes[0].entityId, scopes[0].kind, target.baseline_cursor.key]);
+    }
+});
+/** Drop obsolete scopes without making an unrelated pending scan start over. */
+export const reconcileReplicationScans = (sql, target) => sql.unsafe(`UPDATE _ontology_replication_scans SET complete = true, required = false
+    WHERE generation = $1::uuid AND NOT EXISTS (
+      SELECT 1 FROM jsonb_to_recordset($2::jsonb) AS s("entityId" text, kind text)
+      WHERE s."entityId" = entity_id AND s.kind = record_kind)`, [target.generation, JSON.stringify(replicationScanScopes(target))]);
+const PAGE_SIZE = 250;
+/**
+ * Full snapshots of one affected entity/edge scope. Share lifecycle admission first, then lock
+ * source rows in key order before allocating revisions. Concurrent mutations therefore supersede
+ * these snapshots, including deletes, without holding a business lock for the whole copy.
+ */
+export const advanceReplicationScan = (sql, generation) => Effect.gen(function* () {
+    const scanned = yield* sql.withTransaction(Effect.gen(function* () {
+        yield* sql.unsafe("SET LOCAL statement_timeout = '30s'");
+        yield* sql.unsafe("SET LOCAL lock_timeout = '5s'");
+        yield* shareReplicationLifecycle(sql);
+        const [target] = yield* sql.unsafe(`SELECT * FROM _ontology_replication_targets WHERE generation = $1::uuid FOR NO KEY UPDATE`, [generation]);
+        const [state] = yield* sql.unsafe("SELECT enabled, active_generation::text, version FROM _ontology_replication WHERE id");
+        if (!target || !state?.enabled || state.active_generation !== generation) {
+            return { finish: false, progressed: false };
+        }
+        const [scan] = yield* sql.unsafe(`SELECT id::text, entity_id, record_kind, cursor FROM _ontology_replication_scans
+         WHERE generation = $1::uuid AND NOT complete ORDER BY initial DESC, id LIMIT 1 FOR UPDATE`, [generation]);
+        if (!scan) {
+            return { finish: true, progressed: false };
+        }
+        const entity = target.manifest.entities.find((entity) => entity.id === scan.entity_id);
+        const selection = target.selection.find((item) => item.entityId === scan.entity_id);
+        let records;
+        if (scan.record_kind === "entity") {
+            const fields = selection.fields.includes("id")
+                ? selection.fields
+                : ["id", ...selection.fields];
+            records = `SELECT r.id::text AS record_key,
+          (SELECT jsonb_object_agg(key,value) FROM jsonb_each(${snapshotExpression(entity, "r")})
+            WHERE ${ql(JSON.stringify(fields))}::jsonb ? key) AS payload
+          FROM ${qi(tableName(entity.name))} r
+          WHERE ($2::text = '' OR r.id > NULLIF($2::text,'')::uuid)
+          ORDER BY r.id LIMIT ${PAGE_SIZE} FOR SHARE OF r`;
+        }
+        else {
+            const name = scan.record_kind.slice(5);
+            const relationship = entity.relationships.find((relationship) => relationship.name === name);
+            const columns = joinColumnNames({
+                entity: entity.name,
+                relationship: name,
+                target: relationship.to,
+            });
+            const source = qi(columns.source);
+            const destination = qi(columns.target);
+            records = `SELECT ${source}::text || ':' || ${destination}::text AS record_key,
+          jsonb_build_object('source_id',${source}::text,'target_id',${destination}::text) AS payload
+          FROM ${qi(joinTableName(entity.name, name))}
+          WHERE ($2::text = '' OR (${source},${destination}) >
+            (NULLIF(split_part($2::text,':',1),'')::uuid,NULLIF(split_part($2::text,':',2),'')::uuid))
+          ORDER BY ${source},${destination} LIMIT ${PAGE_SIZE} FOR SHARE`;
+        }
+        const [page] = yield* sql.unsafe(`WITH page AS MATERIALIZED (${records}), valid AS (
+          SELECT NOT EXISTS(SELECT 1 FROM page WHERE octet_length(payload::text) > ${REPLICATION_RECORD_BYTES}) AS ok
+        ), inserted AS (
+          INSERT INTO _ontology_replication_baselines (generation,event)
+          SELECT $1::uuid,jsonb_build_object('source_id',$3::text,'entity_id',$4::text,
+            'record_key',record_key,'record_kind',$5::text,'revision',nextval('_ontology_replication_revision')::text,
+            'deleted',false,'schema_hash',$6::text,'payload',payload::text)
+          FROM page WHERE (SELECT ok FROM valid) RETURNING id,event
+        ), queued AS (
+          INSERT INTO _ontology_replication_delivery
+            (generation,event_id,revision,is_baseline,scan_id${state.version >= 6 ? ",payload_bytes" : ""})
+          SELECT $1::uuid,id,(event->>'revision')::bigint,true,$7::uuid
+            ${state.version >= 6 ? ",octet_length(event::text)" : ""} FROM inserted RETURNING event_id
+        ) SELECT (SELECT count(*)::integer FROM queued) AS count,
+          (SELECT max(record_key) FROM page) AS key, NOT (SELECT ok FROM valid) AS oversized`, [
+            generation,
+            scan.cursor,
+            target.source_id,
+            entity.id,
+            scan.record_kind,
+            target.manifest.hash,
+            scan.id,
+        ]);
+        if (page.oversized) {
+            return yield* new ReplicationBaselineFailed({
+                message: `A projected record exceeds ${REPLICATION_RECORD_BYTES} bytes; ` +
+                    "change the record or its declared projection.",
+            });
+        }
+        yield* sql.unsafe(`UPDATE _ontology_replication_scans SET cursor = COALESCE($2,cursor), complete = $3 WHERE id = $1::uuid`, [scan.id, page.key, page.count < PAGE_SIZE]);
+        return { finish: false, progressed: true };
+    }));
+    if (!scanned.finish) {
+        return { complete: false, progressed: scanned.progressed };
+    }
+    // Finalization must drain admitted writers; never upgrade a shared lifecycle lock in place.
+    return yield* sql.withTransaction(Effect.gen(function* () {
+        yield* sql.unsafe("SET LOCAL statement_timeout = '30s'");
+        yield* sql.unsafe("SET LOCAL lock_timeout = '5s'");
+        yield* lockReplicationLifecycle(sql);
+        const [target] = yield* sql.unsafe(`UPDATE _ontology_replication_targets SET scans_complete = true, baseline_complete = true,
+          initial_revision = COALESCE(initial_revision,
+            (SELECT CASE WHEN is_called THEN last_value ELSE 0 END FROM _ontology_replication_revision))
+         WHERE generation = $1::uuid AND NOT EXISTS (
+           SELECT 1 FROM _ontology_replication_scans WHERE generation = $1::uuid AND NOT complete)
+           AND generation = (SELECT active_generation FROM _ontology_replication WHERE id AND enabled)
+         RETURNING scans_complete AS complete`, [generation]);
+        return { complete: target?.complete ?? false, progressed: target?.complete ?? false };
+    }));
+});
+/** A published schema may add coverage only after its finite scan output is accepted by Pub/Sub. */
+export const replicationScansReady = (sql, generation) => sql
+    .unsafe(`SELECT scans_complete AND NOT EXISTS (
+    SELECT 1 FROM _ontology_replication_delivery d JOIN _ontology_replication_scans s ON s.id = d.scan_id
+    WHERE d.generation = $1::uuid AND s.required AND d.accepted_at IS NULL
+  ) AS ready FROM _ontology_replication_targets WHERE generation = $1::uuid`, [generation])
+    .pipe(Effect.map((rows) => rows[0]?.ready ?? false));

package/dist/replication/schema.d.ts

@@ -0,0 +1,11 @@
+import type { EntityManifest, OntologyManifest } from "../manifest.js";
+export declare const REPLICATION_SCHEMA_VERSION = 6;
+/** Targets of sources not migrated since fills were introduced have no `fills` column. */
+export declare const REPLICATION_TARGET_FILLS = "COALESCE(to_jsonb(_ontology_replication_targets) -> 'fills',\n  '{}'::jsonb) AS fills";
+/** Optional metadata keeps the platform reader compatible with sources not upgraded yet. */
+export declare const REPLICATION_TARGET_METADATA = "\n  to_jsonb(_ontology_replication_targets)->'identities' AS identities,\n  COALESCE(to_jsonb(_ontology_replication_targets)->'lineage', 'null'::jsonb) AS lineage,\n  COALESCE((to_jsonb(_ontology_replication_targets)->>'scans_complete')::boolean, true) AS scans_complete,\n  to_jsonb(_ontology_replication_targets)->'backfill_sources' AS backfill_sources,\n  (SELECT version FROM _ontology_replication WHERE id) AS schema_version";
+/** Installed only by the SDK migration runner, never at service startup. */
+export declare const REPLICATION_DDL: string[];
+export declare function snapshotExpression(entity: EntityManifest, alias: string): string;
+/** History is the durable source. Triggers also reject old writers while capture is enabled. */
+export declare function replicationEntityDdl(manifest: OntologyManifest, previous?: OntologyManifest): ReadonlyArray<string>;