@antelopejs/interface-database-catalog 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2025-present - AntelopeJS Team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,71 @@
-# Temporary Holding Version
+# @antelopejs/interface-database-catalog
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+<div align="center">
+<a href="./LICENSE"><img alt="License" src="https://img.shields.io/badge/License-Apache_2.0-000000?style=for-the-badge&labelColor=000000"></a>
+<a href="https://discord.gg/sjK28QHrA7"><img alt="Discord" src="https://img.shields.io/badge/Discord-18181B?logo=discord&style=for-the-badge&color=000000"></a>
+<a href="https://github.com/AntelopeJS/interface-database-catalog/tree/main/docs"><img alt="Docs" src="https://img.shields.io/badge/Docs-18181B?style=for-the-badge&color=000000"></a>
+</div>
+
+Describes and profiles a database that an [`@antelopejs/interface-database`](https://github.com/AntelopeJS/interface-database) provider is connected to but does not own, so a generator can propose a module whose tables mirror it. It is a development tool: every function refuses outside development.
+
+## What it offers
+
+- `Info` returns the engine, version, database and role of the connection.
+- `ListRelations` lists every relation with its kind, row estimate, key and write privileges, and says why a relation cannot be registered when it cannot.
+- `DescribeRelations` details columns with their native types and the `@Field` declarations they accept, indexes and foreign keys.
+- `Profile` aggregates a relation per column and per foreign key, never returning rows.
+- `CheckReference` measures how much of one column's values another column holds, for references the database does not declare.
+
+The answers follow the provider's own registration rules: a relation the catalog calls mappable registers, and the key it names is the one `_id` aliases.
+
+## Implementations
+
+No public module implements this interface yet. A provider of `@antelopejs/interface-database` that connects to a database it does not own can implement it as well.
+
+## Install
+
+The package is not published to npm yet. Once it is, add it to the module that reads the catalog:
+
+```bash
+pnpm add @antelopejs/interface-database-catalog
+```
+
+## Quick start
+
+```ts
+import { ListRelations } from "@antelopejs/interface-database-catalog";
+
+export async function listMappableRelations() {
+  const relations = await ListRelations(["public"]);
+  return relations
+    .filter((relation) => !relation.unmappable)
+    .map((relation) => `${relation.schema}.${relation.name}`);
+}
+```
+
+Relations are named `"schema.name"`, the form `DescribeRelations` and `Profile` take.
+
+## Documentation
+
+- [Overview](https://github.com/AntelopeJS/interface-database-catalog/blob/main/docs/index.md)
+
+## Compatibility
+
+| Package                             | Range            |
+| ----------------------------------- | ---------------- |
+| `@antelopejs/interface-core` (peer) | `>=0.2.0 <1.0.0` |
+| `@antelopejs/core`                  | `>=1.14.0`       |
+
+## Contributing
+
+Read [CONTRIBUTING.md](./CONTRIBUTING.md) before you open a pull request. The local checks are:
+
+```bash
+pnpm install
+pnpm lint
+pnpm typecheck
+```
+
+## License
+
+[Apache-2.0](./LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,273 @@
+/**
+ * What the connected database is, as the provider's own connection sees it.
+ */
+export interface CatalogInfo {
+    /** The engine's name, e.g. `postgresql`. */
+    engine: string;
+    /** The server's version, e.g. `17.5`. */
+    version: string;
+    /** The database the connection is on. */
+    database: string;
+    /** The role the connection runs as. */
+    role: string;
+}
+/** The kinds of relation a catalog lists. */
+export type RelationKind = "table" | "partitioned" | "view" | "materialized" | "foreign";
+/**
+ * Where a row estimate came from: the database's statistics, its live-tuple counter for a table
+ * never analyzed, or the planner's estimate for a relation that has neither.
+ */
+export type EstimateSource = "statistics" | "live-tuples" | "plan";
+/** Whether a relation's key is its primary key or a unique index that identifies rows as one does. */
+export type KeySource = "primary" | "unique";
+/**
+ * The columns registration aliases `_id` to.
+ */
+export interface RelationKey {
+    columns: string[];
+    source: KeySource;
+}
+/** What the provider's connection may write to a relation. */
+export interface RelationWrites {
+    insert: boolean;
+    update: boolean;
+    delete: boolean;
+}
+/**
+ * One relation of the connected database.
+ *
+ * `key` and `unmappable` are the provider's own registration rules: a relation the summary calls
+ * mappable registers, and a relation without a key registers without `_id`.
+ */
+export interface RelationSummary {
+    /** The native schema, used verbatim as the schema id. */
+    schema: string;
+    /** The native name, used verbatim as the table id. */
+    name: string;
+    kind: RelationKind;
+    estimatedRows: number | null;
+    estimate: EstimateSource | null;
+    key: RelationKey | null;
+    /** Why the relation cannot be registered, when it cannot. */
+    unmappable?: string;
+    writes: RelationWrites;
+    comment: string | null;
+}
+/** How an identity column takes its values. */
+export type IdentityKind = "always" | "by default";
+/**
+ * A field type a column may be declared as, in the spelling `@Field` takes (`"string"`,
+ * `"number"`, `"date"`, `"boolean"`, `"object"`, `"string[]"`, …), with the reason it does not
+ * round-trip when it does not.
+ */
+export interface DeclaredReading {
+    declared: string;
+    lossy?: string;
+}
+/**
+ * One column of a relation.
+ */
+export interface ColumnDescription {
+    /** The native name, used verbatim as the field name. */
+    name: string;
+    /** The native type with its modifiers, e.g. `character varying(200)`. */
+    native: string;
+    nullable: boolean;
+    hasDefault: boolean;
+    generated: boolean;
+    identity: IdentityKind | null;
+    /** An enum's labels, in their sort order. */
+    enumLabels?: string[];
+    /**
+     * The declarations registration accepts for this column, the one a generator should propose
+     * first. Empty when the native type is not supported, and then `unsupported` says why.
+     */
+    accepts: DeclaredReading[];
+    unsupported?: string;
+    /** Why a write never assigns this column, when it never does. */
+    readOnly?: string;
+    comment: string | null;
+}
+/** Columns of one relation, named `"schema.name"`. */
+export interface RelationColumns {
+    relation: string;
+    columns: string[];
+}
+/** A declared foreign key. */
+export interface Reference {
+    name: string;
+    from: RelationColumns;
+    to: RelationColumns;
+}
+/** An index the database holds on a relation. */
+export interface IndexDescription {
+    name: string;
+    columns: string[];
+    unique: boolean;
+}
+/**
+ * A relation in full: its columns, its indexes, and the foreign keys out of it and into it.
+ */
+export interface RelationDescription extends RelationSummary {
+    columns: ColumnDescription[];
+    indexes: IndexDescription[];
+    references: Reference[];
+    referencedBy: Reference[];
+}
+/** A measure that did not finish in its time. */
+export interface MeasureTimeout {
+    status: "timeout";
+}
+/** A measure the database refused, by its error code only. */
+export interface MeasureError {
+    status: "error";
+    code: string;
+}
+/** A measure's value. */
+export interface MeasureValue<T> {
+    status: "ok";
+    value: T;
+}
+/**
+ * The outcome of one measure. A measure that times out or fails leaves the others standing.
+ */
+export type Measure<T> = MeasureValue<T> | MeasureTimeout | MeasureError;
+/** How a profile sampled its relation, when it did. */
+export interface SampleInfo {
+    percent: number;
+    rows: number;
+}
+/** A row count, and whether it was counted or estimated. */
+export interface RowCount {
+    rows: number;
+    exact: boolean;
+}
+/** The ends of a number, date or enum column. Dates are ISO strings. */
+export interface ValueRange {
+    min: number | string;
+    max: number | string;
+}
+/** Rows in one calendar month, `YYYY-MM`, in UTC. */
+export interface MonthCount {
+    month: string;
+    rows: number;
+}
+/** One category of a column, with its rows. */
+export interface CategoryCount {
+    value: string | number | boolean;
+    rows: number;
+}
+/**
+ * The categories of a column with few distinct values. Values counted too rarely to be a
+ * category are folded into `other`, and never named.
+ */
+export interface Categories {
+    values: CategoryCount[];
+    other: number;
+}
+/** Lengths of a text column's values. */
+export interface LengthStats {
+    min: number;
+    avg: number;
+    max: number;
+}
+/**
+ * What a profile concludes about a column, from its measures:
+ * - `enum-like`: an enum, or few distinct values over enough rows;
+ * - `identifier-like`: one distinct value per row, never null;
+ * - `label-candidate`: text that is nearly unique and short enough to show;
+ * - `time-axis`: a date column filled enough and spread over enough months;
+ * - `measure`: a number column that is neither a key nor a reference.
+ */
+export type ColumnTrait = "enum-like" | "identifier-like" | "label-candidate" | "time-axis" | "measure";
+/**
+ * One column's profile. Only measures that apply to the column's type are present.
+ */
+export interface ColumnProfile {
+    name: string;
+    nulls?: Measure<number>;
+    /** A lower bound when the profile is sampled. */
+    distinct?: Measure<number>;
+    range?: Measure<ValueRange>;
+    months?: Measure<MonthCount[]>;
+    categories?: Measure<Categories>;
+    length?: Measure<LengthStats>;
+    traits: ColumnTrait[];
+}
+/** How many children each referenced parent has, over a declared foreign key out of the relation. */
+export interface FanOut {
+    average: number;
+    max: number;
+    parentsWithoutChildren: number;
+}
+/** A declared foreign key out of the profiled relation, with its fan-out. */
+export interface ReferenceProfile {
+    reference: Reference;
+    fanOut: Measure<FanOut>;
+}
+/** A declared foreign key into the profiled relation, with the referring relation's size. */
+export interface InboundProfile {
+    reference: Reference;
+    estimatedRows: number | null;
+}
+/** The relation and columns to profile; every column when `columns` is absent. */
+export interface ProfileRequest {
+    relation: string;
+    columns?: string[];
+}
+/**
+ * Aggregates over a relation. It carries no row: values appear only as enum labels and as
+ * categories.
+ */
+export interface RelationProfile {
+    relation: string;
+    rows: Measure<RowCount>;
+    sample: SampleInfo | null;
+    columns: ColumnProfile[];
+    references: ReferenceProfile[];
+    inbound: InboundProfile[];
+}
+/** One column of one relation, the relation named `"schema.name"`. */
+export interface ColumnReference {
+    relation: string;
+    column: string;
+}
+/** A column that may refer to another without a declared foreign key. */
+export interface ReferenceCheck {
+    from: ColumnReference;
+    to: ColumnReference;
+}
+/**
+ * How much of a column's non-null values the other column holds, and whether that other column
+ * is its relation's key.
+ */
+export interface ReferenceMatch {
+    containment: number;
+    checkedRows: number;
+    sampled: boolean;
+    targetIsKey: boolean;
+}
+/**
+ * The connected database: engine, version, database and role.
+ *
+ * Every function of this interface refuses outside development, and on a provider instance that
+ * owns its tables rather than describing a database it was pointed at.
+ */
+export declare const Info: () => Promise<CatalogInfo>;
+/**
+ * Every relation the connection can see, in the given schemas or in all of them, partitions left
+ * out: their parent is the table.
+ */
+export declare const ListRelations: (schemas?: string[] | undefined) => Promise<RelationSummary[]>;
+/** The named relations, `"schema.name"`, in full. */
+export declare const DescribeRelations: (relations: string[]) => Promise<RelationDescription[]>;
+/**
+ * Aggregates over one relation, read without writing anything and within a time bound per
+ * measure. A large relation is sampled, and the answer says so.
+ */
+export declare const Profile: (request: ProfileRequest) => Promise<RelationProfile>;
+/**
+ * Whether one column's values are found in another's, for a reference the database does not
+ * declare.
+ */
+export declare const CheckReference: (check: ReferenceCheck) => Promise<Measure<ReferenceMatch>>;

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckReference = exports.Profile = exports.DescribeRelations = exports.ListRelations = exports.Info = void 0;
+const interface_core_1 = require("@antelopejs/interface-core");
+/**
+ * The connected database: engine, version, database and role.
+ *
+ * Every function of this interface refuses outside development, and on a provider instance that
+ * owns its tables rather than describing a database it was pointed at.
+ */
+exports.Info = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Every relation the connection can see, in the given schemas or in all of them, partitions left
+ * out: their parent is the table.
+ */
+exports.ListRelations = (0, interface_core_1.InterfaceFunction)();
+/** The named relations, `"schema.name"`, in full. */
+exports.DescribeRelations = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Aggregates over one relation, read without writing anything and within a time bound per
+ * measure. A large relation is sampled, and the answer says so.
+ */
+exports.Profile = (0, interface_core_1.InterfaceFunction)();
+/**
+ * Whether one column's values are found in another's, for a reference the database does not
+ * declare.
+ */
+exports.CheckReference = (0, interface_core_1.InterfaceFunction)();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+DAA+D;AAwS/D;;;;;GAKG;AACU,QAAA,IAAI,GAAG,IAAA,kCAAiB,GAA8B,CAAC;AAEpE;;;GAGG;AACU,QAAA,aAAa,GACxB,IAAA,kCAAiB,GAAsD,CAAC;AAE1E,qDAAqD;AACxC,QAAA,iBAAiB,GAC5B,IAAA,kCAAiB,GAA2D,CAAC;AAE/E;;;GAGG;AACU,QAAA,OAAO,GAClB,IAAA,kCAAiB,GAAyD,CAAC;AAE7E;;;GAGG;AACU,QAAA,cAAc,GACzB,IAAA,kCAAiB,GAEd,CAAC"}

package/docs/index.md

@@ -0,0 +1,48 @@
+# Interface Database Catalog
+
+## Reaching a provider
+
+A module that implements `@antelopejs/interface-database` over a database it does not own may also implement this interface. A consumer reaches it through a connection declared in the project configuration, one per database:
+
+```ts
+"dms-ai": {
+  importOverrides: [
+    { interface: "@antelopejs/interface-database-catalog", source: "postgres-erp", id: "erp" },
+  ],
+},
+```
+
+`GetInterfaceInstances` then lists the declared connections, and `GetInterfaceInstance(catalog, "erp")` reaches that one.
+
+## Functions
+
+| Function                          | Answers                                                                                                                                                |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `Info()`                          | engine, version, database and role of the connection                                                                                                   |
+| `ListRelations(schemas?)`         | every relation, partitions left out: kind, row estimate and its source, key, write privileges, comment, and why it cannot be registered when it cannot |
+| `DescribeRelations(relations)`    | the named relations in full: columns with their native types and the declarations they accept, indexes, foreign keys out and in                        |
+| `Profile({ relation, columns? })` | aggregates per column and per foreign key, and the traits they imply                                                                                   |
+| `CheckReference({ from, to })`    | how much of one column's values another column holds, for a reference the database does not declare                                                    |
+
+Relations are named `"schema.name"`.
+
+## What a profile answers
+
+A profile holds aggregates, never rows:
+
+- counts, null counts and distinct counts;
+- the ends of number, date and enum columns, never of text columns;
+- rows per month for date columns;
+- lengths of text values;
+- children per parent over each foreign key.
+
+Values appear only as enum labels and as **categories**: the most frequent values of a column with few distinct values, each counted often enough to be a category rather than a record. Rarer values are folded into `other` and never named.
+
+Every measure has a time bound. A measure that does not finish answers `{ status: "timeout" }`, and the rest of the profile stands. A large relation is sampled, and `sample` says by how much. A distinct count from a sample is then a lower bound.
+
+## Refusals
+
+Every function refuses:
+
+- outside development;
+- on a provider instance that owns its tables.

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@antelopejs/interface-database-catalog",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "AntelopeJS interface for describing and profiling a connected database",
+  "keywords": [
+    "antelopejs",
+    "catalog",
+    "database",
+    "interface"
+  ],
+  "homepage": "https://github.com/AntelopeJS/interface-database-catalog/tree/main/docs",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AntelopeJS/interface-database-catalog.git"
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "typecheck": "tsc --noEmit",
+    "format": "oxfmt .",
+    "lint:fix": "oxlint --fix",
+    "lint": "oxlint",
+    "prepack": "pnpm run build",
+    "release": "pnpm run lint && pnpm run prepack && release-it",
+    "format:check": "oxfmt --check .",
+    "knip": "knip"
+  },
+  "devDependencies": {
+    "@antelopejs/interface-core": ">=0.2.0 <1.0.0",
+    "@antelopejs/tooling-configs": "^0.0.8",
+    "@types/node": "^22.19.15",
+    "knip": "^6.34.0",
+    "oxfmt": "^0.66.0",
+    "oxlint": "1.81.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "release-it": "^19.2.4",
+    "release-it-changelogen": "^0.1.0",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@antelopejs/interface-core": ">=0.2.0 <1.0.0"
+  },
+  "packageManager": "pnpm@10.6.5"
+}