@seedprotocol/sdk 0.7.4-next.793.g6dd83dd → 0.7.5-next.850.g9ab585b

package/README.md

@@ -0,0 +1,99 @@
+# @seedprotocol/sdk
+
+[![npm](https://img.shields.io/npm/v/@seedprotocol/sdk.svg)](https://www.npmjs.com/package/@seedprotocol/sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/node/v/@seedprotocol/sdk.svg)](https://nodejs.org)
+[![Docs](https://img.shields.io/badge/docs-seedprotocol.io-0B6E4F)](https://seedprotocol.io)
+
+The official TypeScript SDK for [Seed Protocol](https://seedprotocol.io): a local-first, decentralized data layer.
+
+**[→ Full documentation at seedprotocol.io](https://seedprotocol.io)**
+
+## What it does
+
+- **Local-first ORM.** Define schemas, models and properties; the SDK stores items in SQLite and files in OPFS in the user's browser (or on disk in Node).
+- **Decentralized sync.** Data is read from and published to the [Ethereum Attestation Service (EAS)](https://attest.sh) and [Arweave](https://www.arweave.org). There is no backend for you to run.
+- **No custody.** User data lives on public infrastructure and in the user's browser, not on your servers.
+
+Built and used by [PermaPress](https://permapress.xyz), the first client for Seed Protocol (by [JournoLabs](https://journolabs.xyz)).
+
+## Requirements
+
+- **Node.js** `>= 20` and `<= 24`
+- **Browser:** a modern browser with OPFS (e.g. Chromium-based, recent Firefox)
+
+## Installation
+
+```bash
+npm install @seedprotocol/sdk
+# or
+bun add @seedprotocol/sdk
+# or
+pnpm add @seedprotocol/sdk
+```
+
+Browser apps built with Vite should also add [`@seedprotocol/vite`](https://www.npmjs.com/package/@seedprotocol/vite). For React hooks, add [`@seedprotocol/react`](https://www.npmjs.com/package/@seedprotocol/react).
+
+## Quick start
+
+Initialize the client once, then create schemas, models and items:
+
+```ts
+import { client, Schema, Model } from '@seedprotocol/sdk'
+
+await client.init({
+  config: {
+    filesDir: '.seed',
+    endpoints: { filePaths: '/files', files: '.seed' }, // optional on Node when filesDir is set
+  },
+})
+
+const schema = await Schema.create('Blog')
+
+const Post = await Model.create('Post', schema, {
+  properties: {
+    title: { dataType: 'Text' },
+    content: { dataType: 'Html' },
+    publishedAt: { dataType: 'Date' },
+  },
+})
+
+const post = await Post.create({ title: 'Hello', content: '<p>First post</p>' })
+
+// Update by assignment; the SDK persists the change.
+post.title = 'Hello, world'
+```
+
+You can also declare your schema in a config file at the project root: `seed.config.ts` (recommended), `seed.schema.ts`, or `schema.ts`.
+
+To publish items to EAS and Arweave, use [`@seedprotocol/publish`](https://www.npmjs.com/package/@seedprotocol/publish).
+
+See the [Getting Started guide](https://github.com/JournoLabs/seed-protocol-sdk/blob/main/docs/GETTING_STARTED.md) for configuration, address sessions, property types, files and images.
+
+## Entry points
+
+| Import | Use |
+| --- | --- |
+| `@seedprotocol/sdk` | Main API: `client`, `Schema`, `Model`, `Item`, `ItemProperty`, query helpers |
+| `@seedprotocol/sdk/node` | Node entry: `client`, `Item`, `FileManager`, `Db`, and `withSeed` for webpack configs |
+| `@seedprotocol/sdk/platform` | Platform services: `configurePlatform`, `createPlatformServices` |
+| `@seedprotocol/sdk/vite` | Re-export of `seedVitePlugin` from `@seedprotocol/vite` |
+
+ESM is recommended. CommonJS also works: `const { Schema, Model, Item } = require('@seedprotocol/sdk')`.
+
+## Related packages
+
+| Package | Description |
+| --- | --- |
+| [`@seedprotocol/react`](https://www.npmjs.com/package/@seedprotocol/react) | React hooks and components |
+| [`@seedprotocol/publish`](https://www.npmjs.com/package/@seedprotocol/publish) | Publish flow (EAS attestations + Arweave uploads) |
+| [`@seedprotocol/vite`](https://www.npmjs.com/package/@seedprotocol/vite) | Vite plugin for browser apps |
+| [`@seedprotocol/query`](https://www.npmjs.com/package/@seedprotocol/query) | Canonical Seed JSON queries over EAS or local SQLite |
+| [`@seedprotocol/feed`](https://www.npmjs.com/package/@seedprotocol/feed) | RSS, Atom and JSON Feed generation |
+| [`@seedprotocol/mapping`](https://www.npmjs.com/package/@seedprotocol/mapping) | Field mapping from external sources to models |
+| [`@seedprotocol/eas`](https://www.npmjs.com/package/@seedprotocol/eas) | EAS GraphQL read client |
+| [`@seedprotocol/arweave`](https://www.npmjs.com/package/@seedprotocol/arweave) | Arweave gateway client |
+
+## License
+
+MIT

package/dist/{BasePathResolver-DT63t0XU.js → BasePathResolver-CsZHPrk9.js}

@@ -1,19 +1,18 @@
 import debug from 'debug';
 import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls, getTransactionTagsByIds } from '@seedprotocol/arweave';
-import { BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
+import { easName, DEFAULT_NAME_MATCH_LEVEL, compareNameMatchTiers, isNameMatchLevel, localNamesInBestMatchTier, BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
 import { waitFor } from 'xstate';
-import 'pluralize';
+import pluralize from 'pluralize';
 import { Type } from '@sinclair/typebox';
 import { sqliteTable, integer, text, unique, int, blob, uniqueIndex } from 'drizzle-orm/sqlite-core';
 import { relations, and, eq, inArray, desc, isNull, isNotNull, or } from 'drizzle-orm';
-import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
-import { upperFirst, camelCase, throttle } from 'lodash-es';
 import { customAlphabet } from 'nanoid';
 import { alphanumeric } from 'nanoid-dictionary';
 import '@seedprotocol/query';
 import { sha256 } from '@noble/hashes/sha256';
 import { sha3_256 } from '@noble/hashes/sha3';
 import { bytesToHex } from '@noble/hashes/utils';
+import { throttle } from 'lodash-es';
 
 class BaseDb {
     static configure(impl) {
@@ -468,6 +467,171 @@ const Property = {
     /** `Html` opts are not representable in `TPropertyConstructor`; keep runtime shape via double assert. */
 };
 
+/** Ref model name when propDef is a List of Relation, else undefined. */
+function listRelationRef(propDef) {
+    if (!propDef)
+        return undefined;
+    if (normalizeDataType(propDef.dataType) !== 'List')
+        return undefined;
+    return propDef.ref || propDef.refModelName || undefined;
+}
+/**
+ * Storage/EAS name for a List-of-relation property (`authorIdentityIds`), given either its
+ * schema key (`authors`) or its storage name. A name already in storage form is returned as-is,
+ * so this is safe on ItemProperties built before their schema was known.
+ * Returns undefined when propDef is not a List of Relation.
+ */
+function listRelationEasPropertyName(propertyName, propDef) {
+    const ref = listRelationRef(propDef);
+    if (!ref || !propertyName)
+        return undefined;
+    if (propertyName.endsWith(`${ref}Ids`))
+        return propertyName;
+    return `${pluralize(propertyName, 1)}${ref}Ids`;
+}
+/**
+ * For a schema property key like `authors` (List of Relation to Identity), returns the
+ * internal storage/EAS name: `authorIdentityIds` (singular + ref + Ids).
+ */
+function listRelationStoragePropertyName(propertySchemas, schemaPropertyKey) {
+    return listRelationEasPropertyName(schemaPropertyKey, propertySchemas[schemaPropertyKey]);
+}
+/**
+ * Reverse of listRelationStoragePropertyName: maps DB/EAS name `authorIdentityIds` to schema key `authors`.
+ */
+function resolveStorageNameToSchemaName(propertySchemas, storagePropertyName) {
+    for (const [schemaKey, propDef] of Object.entries(propertySchemas)) {
+        if (normalizeDataType(propDef?.dataType) !== 'List')
+            continue;
+        const ref = propDef.ref || propDef.refModelName;
+        if (!ref)
+            continue;
+        const internalName = `${pluralize(schemaKey, 1)}${ref}Ids`;
+        if (internalName === storagePropertyName) {
+            return schemaKey;
+        }
+    }
+    return undefined;
+}
+/** Internal property names that never use Id-suffix metadata convention */
+const ID_SUFFIX_EXCLUDE = new Set(['storageTransactionId', 'transactionId']);
+/** Data types that store metadata with Id suffix in DB */
+const METADATA_ID_SUFFIX_TYPES = ['Image', 'File', 'Html', 'Relation'];
+/**
+ * Whether this type uses Id suffix in metadata table.
+ */
+function needsMetadataIdSuffix(dataType, refValueType) {
+    const dt = normalizeDataType(dataType);
+    const rvt = normalizeDataType(refValueType);
+    return (METADATA_ID_SUFFIX_TYPES.includes(dt) ||
+        METADATA_ID_SUFFIX_TYPES.includes(rvt));
+}
+/**
+ * Canonical metadata property name for WRITES.
+ * Use when creating/updating metadata.
+ */
+function toMetadataPropertyName(propertyName, dataType, refValueType) {
+    if (ID_SUFFIX_EXCLUDE.has(propertyName))
+        return propertyName;
+    if (propertyName.endsWith('Ids'))
+        return propertyName;
+    if (propertyName.endsWith('Id'))
+        return propertyName;
+    if (needsMetadataIdSuffix(dataType, refValueType)) {
+        return `${propertyName}Id`;
+    }
+    return propertyName;
+}
+/**
+ * For READS: property names to include in OR query (both variants).
+ * When dataType is undefined, includes all variants for safety (backwards compat with getPropertyData).
+ */
+function getMetadataPropertyNamesForQuery(propertyName, dataType, refValueType) {
+    if (ID_SUFFIX_EXCLUDE.has(propertyName))
+        return [propertyName];
+    if (propertyName.endsWith('Ids'))
+        return [propertyName];
+    if (propertyName.endsWith('Id')) {
+        const base = propertyName.slice(0, -2);
+        return [propertyName, base];
+    }
+    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
+        (dataType === undefined && refValueType === undefined);
+    if (needsId) {
+        return [propertyName, `${propertyName}Id`, `${propertyName}Ids`];
+    }
+    return [propertyName];
+}
+/**
+ * Schema property name from metadata name (strip Id/Ids suffix).
+ */
+function toSchemaPropertyName(propertyName) {
+    if (propertyName.endsWith('Ids'))
+        return propertyName.slice(0, -3);
+    if (propertyName.endsWith('Id'))
+        return propertyName.slice(0, -2);
+    return undefined;
+}
+/**
+ * Alternate property name for instance lookup (base <-> Id variant).
+ */
+function getAlternatePropertyNameForInstanceLookup(propertyName) {
+    if (ID_SUFFIX_EXCLUDE.has(propertyName))
+        return undefined;
+    if (propertyName.endsWith('Id'))
+        return propertyName.slice(0, -2);
+    return `${propertyName}Id`;
+}
+/**
+ * Resolve the best metadata record when multiple variants exist (base + Id).
+ * For Image/File/Html: prefer the record with refResolvedValue (Id variant has filename).
+ */
+function resolveMetadataRecord(records, preferredPropertyName, dataType, refValueType) {
+    if (records.length === 0)
+        throw new Error('No records to resolve');
+    if (records.length === 1)
+        return records[0];
+    const needsId = needsMetadataIdSuffix(dataType, refValueType) ||
+        (dataType === undefined && refValueType === undefined);
+    // For Image/File/Html: prefer the record with refResolvedValue (Id variant has filename)
+    if (needsId) {
+        const withRef = records.find((r) => r.refResolvedValue);
+        if (withRef)
+            return withRef;
+    }
+    // Also prefer by refSeedType when we need file ref
+    if (needsId) {
+        const byRefSeed = records.find((r) => r.refSeedType === 'image' ||
+            r.refSeedType === 'file' ||
+            r.refSeedType === 'html');
+        if (byRefSeed)
+            return byRefSeed;
+    }
+    // Fallback: prefer exact propertyName match, else first
+    return (records.find((r) => r.propertyName === preferredPropertyName) ?? records[0]);
+}
+/**
+ * The EAS property name publish writes for an item property (ADR 0008 §3), already in EAS form:
+ *
+ * - List of relations: its `<name><Model>Ids` storage name (`author_identity_ids`).
+ * - Single Relation, Image, File or Html: its schema key (`author`), never the local `<name>Id`
+ *   storage name. The key is `propertyDef.name` when known, else `propertyName` without its `Id`.
+ * - Anything else: the property name.
+ */
+function easPropertyNameForPublish(propertyName, propertyDef) {
+    const listRelationName = listRelationEasPropertyName(propertyName, propertyDef ?? undefined);
+    if (listRelationName)
+        return easName(listRelationName);
+    if (propertyDef &&
+        normalizeDataType(propertyDef.dataType) !== 'List' &&
+        needsMetadataIdSuffix(propertyDef.dataType, propertyDef.refValueType) &&
+        !ID_SUFFIX_EXCLUDE.has(propertyName)) {
+        const key = propertyDef.name ?? (propertyName.endsWith('Id') ? propertyName.slice(0, -2) : propertyName);
+        return easName(key);
+    }
+    return easName(propertyName);
+}
+
 /** Same rules as getCorrectId in helpers/index (avoid barrel circular import). */
 function parseLocalIdOrUid(localIdOrUid) {
     const id = { localId: undefined, uid: undefined };
@@ -1143,6 +1307,133 @@ function stackWithoutFrames(stack) {
         .join('\n');
 }
 
+const level = (value) => (isNameMatchLevel(value) ? value : undefined);
+const tighter = (a, b) => a === undefined || compareNameMatchTiers(b, a) < 0 ? b : a;
+/** The levels in one schema file for one of its models, or undefined when the file lacks the model. */
+const modelLevelsFromFile = (file, modelName) => {
+    const modelDef = file.models?.[modelName];
+    if (!modelDef)
+        return undefined;
+    const model = level(modelDef.nameMatch) ?? level(file.nameMatch) ?? DEFAULT_NAME_MATCH_LEVEL;
+    const properties = new Map();
+    for (const [propertyName, def] of Object.entries(modelDef.properties ?? {})) {
+        properties.set(propertyName, level(def?.nameMatch) ?? model);
+    }
+    return { model, properties };
+};
+/**
+ * Builds NameMatchLevels from the schema files that own each model row. Exported for tests;
+ * use {@link nameMatchLevels}.
+ */
+const nameMatchLevelsFromRows = (rows) => {
+    const byFileId = new Map();
+    const byName = new Map();
+    const parsed = new Map();
+    for (const row of rows) {
+        if (!row.schemaData)
+            continue;
+        if (!parsed.has(row.schemaData)) {
+            try {
+                parsed.set(row.schemaData, JSON.parse(row.schemaData));
+            }
+            catch {
+                parsed.set(row.schemaData, undefined);
+            }
+        }
+        const file = parsed.get(row.schemaData);
+        const levels = file && modelLevelsFromFile(file, row.modelName);
+        if (!levels)
+            continue;
+        if (row.modelFileId)
+            byFileId.set(row.modelFileId, levels);
+        const seen = byName.get(row.modelName);
+        if (!seen) {
+            byName.set(row.modelName, { model: levels.model, properties: new Map(levels.properties) });
+            continue;
+        }
+        seen.model = tighter(seen.model, levels.model);
+        for (const [name, value] of levels.properties)
+            seen.properties.set(name, tighter(seen.properties.get(name), value));
+    }
+    return {
+        model: (modelName) => byName.get(modelName)?.model ?? DEFAULT_NAME_MATCH_LEVEL,
+        property: (modelName, propertyName, modelFileId) => {
+            const levels = (modelFileId ? byFileId.get(modelFileId) : undefined) ?? byName.get(modelName);
+            return levels?.properties.get(propertyName) ?? levels?.model ?? DEFAULT_NAME_MATCH_LEVEL;
+        },
+    };
+};
+const DEFAULT_LEVELS = {
+    model: () => DEFAULT_NAME_MATCH_LEVEL,
+    property: () => DEFAULT_NAME_MATCH_LEVEL,
+};
+let current;
+let loading;
+/** Reads the levels from the schema files stored with each model's schema row (schemas.schema_data). */
+const loadNameMatchLevels = async (db = BaseDb.getAppDb()) => {
+    if (!db)
+        return DEFAULT_LEVELS;
+    const load = (async () => {
+        const rows = (await db
+            .select({ modelName: models.name, modelFileId: models.schemaFileId, schemaData: schemas.schemaData })
+            .from(models)
+            .innerJoin(modelSchemas, eq(models.id, modelSchemas.modelId))
+            .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id)));
+        return nameMatchLevelsFromRows(rows);
+    })();
+    loading = load;
+    try {
+        const levels = await load;
+        if (loading === load)
+            current = levels;
+        return levels;
+    }
+    finally {
+        if (loading === load)
+            loading = undefined;
+    }
+};
+/** The levels, loaded once and reused until a schema write clears them. */
+const nameMatchLevels = async (db = BaseDb.getAppDb()) => current ?? loading ?? loadNameMatchLevels(db);
+/**
+ * The last loaded levels, for synchronous callers (Model.findByModelType). Sync and the post-init
+ * model type pass load them; before that every name is at DEFAULT_NAME_MATCH_LEVEL.
+ */
+const currentNameMatchLevels = () => current ?? DEFAULT_LEVELS;
+/** Called when a schema row or its models are written, so the next read reloads. */
+const clearNameMatchLevels = () => {
+    current = undefined;
+    loading = undefined;
+};
+/**
+ * `nameMatch` values in a schema file that aren't a level. They are ignored (the next level up
+ * applies); schema loads warn about them.
+ */
+const invalidNameMatchValues = (file) => {
+    const problems = [];
+    const check = (where, value) => {
+        if (value !== undefined && !isNameMatchLevel(value)) {
+            problems.push(`${where} nameMatch ${JSON.stringify(value)} is not 'exact', 'normalized' or 'fuzzy'`);
+        }
+    };
+    check('schema', file.nameMatch);
+    for (const [modelName, modelDef] of Object.entries(file.models ?? {})) {
+        check(modelName, modelDef?.nameMatch);
+        for (const [propertyName, def] of Object.entries(modelDef?.properties ?? {})) {
+            check(`${modelName}.${propertyName}`, def?.nameMatch);
+        }
+    }
+    return problems;
+};
+/** Warns about {@link invalidNameMatchValues}. */
+const warnOnInvalidNameMatch = (file) => {
+    const problems = invalidNameMatchValues(file);
+    for (const problem of problems) {
+        console.warn(`[seed] schema ${file.metadata?.name ?? ''}: ${problem}; it is ignored.`);
+    }
+    return problems;
+};
+
 /**
  * Thrown when a model name exists in more than one schema and nothing says which one is meant.
  * Model names are only unique within a schema; pass `schemaName` (or `modelFileId`) to choose.
@@ -1224,16 +1515,18 @@ const resolveModelRecordByNameOnly = async (modelName, db, label = Array.isArray
     return { id: chosen.id, name: chosen.name, schemaFileId: chosen.schemaFileId };
 };
 /**
- * The model names a model name or EAS model type can refer to: the name itself, names whose
- * snake_case form is the type (`new_model` → "New model", as Model.findByModelType matches), and
- * the PascalCase form older callers relied on (`sync_storage_post` → "SyncStoragePost").
+ * The model names a model name or EAS model type can refer to: the name itself, else the names
+ * that match it in the tightest tier (ADR 0008, as Model.findByModelType matches): `new_model` →
+ * "New model", `sync_storage_post` → "SyncStoragePost", `htmlpage` → "HTMLPage". Each name at its
+ * nameMatch level (ADR 0009).
  */
 const modelNamesForNameOrType = async (nameOrType, db) => {
-    const pascal = upperFirst(camelCase(nameOrType));
     const rows = (await db.selectDistinct({ name: models.name }).from(models));
-    return rows
-        .map((r) => r.name)
-        .filter((name) => name === nameOrType || name === pascal || toSnakeCase$1(name) === nameOrType);
+    const names = rows.map((r) => r.name);
+    if (names.includes(nameOrType))
+        return [nameOrType];
+    const levels = await nameMatchLevels(db);
+    return [...localNamesInBestMatchTier(nameOrType, names, { level: (name) => levels.model(name) })];
 };
 /**
  * resolveModelRecord for a model name **or** an EAS model type (snake_case model name, what sync
@@ -1580,7 +1873,7 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
             .where(eq(metadata.propertyId, propertyId));
     }
     // Fallback: update metadata with null propertyId (legacy rows) by propertyName + modelType
-    const modelType = toSnakeCase$1(modelName);
+    const modelType = easName(modelName);
     const toUpdateByFallback = await db
         .select({ localId: metadata.localId })
         .from(metadata)
@@ -1601,6 +1894,45 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
     }
     return total;
 }
+/**
+ * Moves a renamed property's metadata rows to its new name: rows linked by propertyId, and legacy
+ * rows without one by name and model type. Each stored form of the name moves to the same form of
+ * the new one: the key (`author` → `writer`), a single relation's `<key>Id` (`authorId` →
+ * `writerId`), a list relation's storage name (`authorIdentityIds` → `writerIdentityIds`).
+ * Returns the number of rows moved.
+ */
+async function moveMetadataToRenamedProperty(db, { propertyId, modelType, oldName, newName, propertyDef, }) {
+    const forms = (name) => [
+        name,
+        toMetadataPropertyName(name, propertyDef?.dataType, propertyDef?.refValueType),
+        listRelationEasPropertyName(name, propertyDef) ?? name,
+    ];
+    const oldForms = forms(oldName);
+    const newForms = forms(newName);
+    let moved = 0;
+    const seen = new Set();
+    for (let i = 0; i < oldForms.length; i++) {
+        const from = oldForms[i];
+        const to = newForms[i];
+        if (from === to || seen.has(from))
+            continue;
+        seen.add(from);
+        const byId = await db
+            .update(metadata)
+            .set({ propertyName: to })
+            .where(and(eq(metadata.propertyId, propertyId), eq(metadata.propertyName, from)))
+            .returning({ localId: metadata.localId });
+        const legacy = await db
+            .update(metadata)
+            .set({ propertyName: to })
+            .where(and(isNull(metadata.propertyId), eq(metadata.propertyName, from), eq(metadata.modelType, modelType)))
+            .returning({ localId: metadata.localId });
+        moved += byId.length + legacy.length;
+    }
+    if (moved > 0)
+        logger$3(`[moveMetadataToRenamedProperty] moved ${moved} metadata rows ${oldName} -> ${newName}`);
+    return moved;
+}
 const getObjectForRow = (row) => {
     const obj = {};
     row.columnNames.forEach((colName, index) => {
@@ -1882,6 +2214,8 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
     if (!db) {
         throw new Error('Database not found');
     }
+    // The stored schema file may change its nameMatch levels (ADR 0009).
+    clearNameMatchLevels();
     // First, try to find existing schema by schemaFileId (preferred for change tracking)
     if (schemaFileId) {
         const existingByFileId = await db
@@ -2350,6 +2684,8 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
     if (!db) {
         throw new Error('Database not found');
     }
+    // Model rows and their schema links decide which schema file's nameMatch applies (ADR 0009).
+    clearNameMatchLevels();
     // If schema is provided, add it to the database
     // Note: schema might already be a database record (with id) if passed from importJsonSchema
     let schemaRecord;
@@ -2504,27 +2840,8 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                     // If refValueType is not set, ensure it's null
                     propertyData.refValueType = null;
                 }
-                // If not found by name, try to find by position/characteristics (for renamed properties)
-                if (!existingProperty) {
-                    // Look for unmatched DB properties that could be this renamed property
-                    // Match by: same dataType, same refModelId (if applicable), and not matching any schema property name
-                    const potentialMatches = allDbProperties.filter((p) => !matchedDbPropertyIds.has(p.id) &&
-                        !schemaPropertyNames.has(p.name) && // This DB property doesn't match any schema property name
-                        p.dataType === propertyValues.dataType &&
-                        (expectedRefModelId === null
-                            ? p.refModelId === null
-                            : p.refModelId === expectedRefModelId) &&
-                        (propertyValues.refValueType
-                            ? p.refValueType === propertyValues.refValueType
-                            : p.refValueType === null));
-                    // If we find exactly one match, or if we're at the same position index, use it
-                    // For now, use the first match (could be enhanced to use position more precisely)
-                    if (potentialMatches.length > 0) {
-                        const matchedProperty = potentialMatches[0];
-                        existingProperty = matchedProperty;
-                        logger$3(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
-                    }
-                }
+                // ADR 0008: a rename needs the property's id. A name that matches no stored property by id
+                // or name is a new property, even if one of the same type was removed in the same edit.
                 if (existingProperty) {
                     // Mark this DB property as matched
                     matchedDbPropertyIds.add(existingProperty.id);
@@ -2582,6 +2899,16 @@ const addModelsToDb = async (models$1, schema, modelRenames, schemaFileData) =>
                         if (updatedFileId)
                             updatedPropertyFileIds.push(updatedFileId);
                     }
+                    if (existingProperty.name !== propertyName) {
+                        // Renamed (matched by id): its values move to the new name.
+                        await moveMetadataToRenamedProperty(db, {
+                            propertyId: existingProperty.id,
+                            modelType: easName(modelName),
+                            oldName: existingProperty.name,
+                            newName: propertyName,
+                            propertyDef: propertyValues,
+                        });
+                    }
                 }
                 else {
                     // Property doesn't exist, create it with schemaFileId
@@ -3524,6 +3851,7 @@ var db = /*#__PURE__*/Object.freeze({
     getWatchedAddressesFromDb: getWatchedAddressesFromDb,
     loadModelsFromDbForSchema: loadModelsFromDbForSchema,
     migrateMetadataForPropertyRename: migrateMetadataForPropertyRename,
+    moveMetadataToRenamedProperty: moveMetadataToRenamedProperty,
     propertyStorageColumns: propertyStorageColumns,
     renameModelInDb: renameModelInDb,
     savePropertyToDb: savePropertyToDb,
@@ -3743,7 +4071,7 @@ const syncDbFiles = async (endpoints) => {
 const getAppDbReady = async () => {
     if (!BaseDb.isAppDbReady()) {
         // Wait for ClientManager to be ready (DB_INIT state or later)
-        const _mod_0 = await import('./ClientManager-Cos8NaRU.js');
+        const _mod_0 = await import('./ClientManager-DETTj0_z.js');
         const _ns_0 = _mod_0.M;
         const clientManagerMod = _ns_0;
         const { getClient } = clientManagerMod;
@@ -4139,8 +4467,9 @@ const INTERNAL_DATA_TYPES = {
     Text: {
         eas: 'string',
     },
+    // ADR 0010: decimal strings, so negatives, fractions and values above 255 publish.
     Number: {
-        eas: 'uint8',
+        eas: 'string',
     },
     Image: {
         eas: 'bytes32',
@@ -4487,9 +4816,6 @@ var generateId$1 = /*#__PURE__*/Object.freeze({
 });
 
 const logger = debug('seedSdk:shared:helpers');
-const toSnakeCase = (str) => {
-    return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-};
 const getMimeType = (base64) => {
     if (!base64) {
         return null;
@@ -4639,5 +4965,5 @@ class BasePathResolver {
 }
 BasePathResolver._impl = null;
 
-export { generateId as $, seeds as A, uploadProcesses as B, versions as C, DEFAULT_TEXT_MAX_LENGTH as D, BaseDb as E, AmbiguousModelError as F, eventEmitter as G, toSnakeCase as H, BasePathResolver as I, BaseFileManager as J, getPropertyIdForModelAndName as K, resolveItemModelFileId as L, ModelPropertyDataTypes as M, resolveSeedIdsFromRefString as N, normalizeRelationPropertyValue as O, Property as P, isPublishedSeedRef as Q, getStorageDirForDataType as R, getContentSha256 as S, THtmlEmbeddedDataUriPolicy as T, buildArweaveContentTags as U, getItemStorageSubdir as V, getItemStorageLocalFileName as W, normalizePublisher as X, getAllAddressesFromDb as Y, scheduleBulkFilesDownloadFromEasSync as Z, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as _, TProperty as a, BaseFileManager$1 as a$, normalizeHexAddress as a0, getItemStoragePropertiesForModel as a1, addModelsToDb as a2, INIT_SCRIPT_SUCCESS_MESSAGE as a3, SCHEMA_TS as a4, getCorrectId as a5, SEED_CONFIG_FILE as a6, SEED_CONFIG_FALLBACKS as a7, isNode as a8, ZERO_BYTES32 as a9, normalizeAddressConfig as aA, normalizeAddressList as aB, normalizeArweaveTxIdForEnsure as aC, normalizeFeedItemFields as aD, resolveMediaRef as aE, isInternalSchema as aF, writeModelToDb as aG, writePropertyToDb as aH, addSchemaToDb as aI, renameModelInDb as aJ, loadModelsFromDbForSchema as aK, downloadAllFilesRequestHandler as aL, downloadAllFilesBinaryRequestHandler as aM, INTERNAL_SCHEMA_IDS as aN, linkModelToSchema as aO, getWatchedAddressesFromDb as aP, getOwnedAddressesFromDb as aQ, CLIENT_NOT_INITIALIZED as aR, getStorageTransactionIdForSeedUid as aS, convertTxIdToImage as aT, downloadTransactionIdWithDedupe as aU, getPropertyIdForSchemaFileId as aV, getDataTypeFromString as aW, getMimeType as aX, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP as aY, BaseDb$1 as aZ, ModelSchema as a_, resolveModelRecord as aa, getItemModelScope as ab, VERSION_SCHEMA_UID as ac, INTERNAL_PROPERTY_NAMES as ad, isStorageSeedRef as ae, defaultAttestationData as af, INTERNAL_DATA_TYPES as ag, isBrowser as ah, getModelIdByFileId as ai, getModelId as aj, setCachedPropertyRefresher as ak, getArweaveUrlForTransaction as al, INTERNAL_STORAGE_MODEL_FILE_IDS as am, CONTENT_SHA256_TAG as an, CONTENT_TYPE_TAG as ao, ImageSize as ap, SEED_PROTOCOL_SCHEMA_NAME as aq, SeedModels as ar, VERSION_SCHEMA_DEF as as, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as at, classifyMediaRef as au, closestImageSize as av, contentSha256TagMatches as aw, ensureImageLocal as ax, getAddressesForItemsFilter as ay, getFeedItemStringField as az, TPropertyConstructor as b, SchemaSchema as b0, ModelSchemaSchema as b1, resolveModelRecord$1 as b2, db as b3, download as b4, generateId$1 as b5, TPropertyDataType as c, TPropertyDefs as d, TStorageType as e, TValidationRules as f, normalizePropertyRecordSchema as g, appState as h, isDataType as i, arweaveL1FinalizeJobs as j, config as k, easSyncProcesses as l, metadata as m, normalizeDataType as n, htmlEmbeddedImageCoPublish as o, modelRelations as p, modelSchemas as q, modelUids as r, models as s, modelsRelations as t, properties as u, propertiesRelations as v, propertyUidRelations as w, propertyUids as x, publishProcesses as y, schemas as z };
-//# sourceMappingURL=BasePathResolver-DT63t0XU.js.map
+export { getCorrectId as $, seeds as A, uploadProcesses as B, versions as C, DEFAULT_TEXT_MAX_LENGTH as D, BaseDb as E, resolveStorageNameToSchemaName as F, AmbiguousModelError as G, eventEmitter as H, nameMatchLevels as I, BasePathResolver as J, BaseFileManager as K, getPropertyIdForModelAndName as L, ModelPropertyDataTypes as M, resolveItemModelFileId as N, resolveSeedIdsFromRefString as O, Property as P, normalizeRelationPropertyValue as Q, isPublishedSeedRef as R, getStorageDirForDataType as S, THtmlEmbeddedDataUriPolicy as T, getContentSha256 as U, buildArweaveContentTags as V, getItemStorageSubdir as W, getItemStorageLocalFileName as X, addModelsToDb as Y, INIT_SCRIPT_SUCCESS_MESSAGE as Z, SCHEMA_TS as _, TProperty as a, getStorageTransactionIdForSeedUid as a$, SEED_CONFIG_FILE as a0, SEED_CONFIG_FALLBACKS as a1, isNode as a2, ZERO_BYTES32 as a3, resolveModelRecord as a4, getItemModelScope as a5, VERSION_SCHEMA_UID as a6, INTERNAL_PROPERTY_NAMES as a7, isStorageSeedRef as a8, defaultAttestationData as a9, closestImageSize as aA, contentSha256TagMatches as aB, ensureImageLocal as aC, getAddressesForItemsFilter as aD, getFeedItemStringField as aE, normalizeAddressConfig as aF, normalizeAddressList as aG, normalizeArweaveTxIdForEnsure as aH, normalizeFeedItemFields as aI, resolveMediaRef as aJ, isInternalSchema as aK, writeModelToDb as aL, writePropertyToDb as aM, addSchemaToDb as aN, renameModelInDb as aO, currentNameMatchLevels as aP, loadModelsFromDbForSchema as aQ, clearNameMatchLevels as aR, downloadAllFilesRequestHandler as aS, downloadAllFilesBinaryRequestHandler as aT, warnOnInvalidNameMatch as aU, INTERNAL_SCHEMA_IDS as aV, linkModelToSchema as aW, getWatchedAddressesFromDb as aX, getOwnedAddressesFromDb as aY, CLIENT_NOT_INITIALIZED as aZ, toSchemaPropertyName as a_, INTERNAL_DATA_TYPES as aa, listRelationEasPropertyName as ab, easPropertyNameForPublish as ac, isBrowser as ad, EAS_SEED_DATA_SYNCED_TO_DB_EVENT as ae, normalizePublisher as af, getAllAddressesFromDb as ag, loadNameMatchLevels as ah, scheduleBulkFilesDownloadFromEasSync as ai, generateId as aj, normalizeHexAddress as ak, toMetadataPropertyName as al, getItemStoragePropertiesForModel as am, getModelIdByFileId as an, getModelId as ao, setCachedPropertyRefresher as ap, getArweaveUrlForTransaction as aq, INTERNAL_STORAGE_MODEL_FILE_IDS as ar, CONTENT_SHA256_TAG as as, CONTENT_TYPE_TAG as at, ImageSize as au, SEED_PROTOCOL_SCHEMA_NAME as av, SeedModels as aw, VERSION_SCHEMA_DEF as ax, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as ay, classifyMediaRef as az, TPropertyConstructor as b, convertTxIdToImage as b0, getMetadataPropertyNamesForQuery as b1, downloadTransactionIdWithDedupe as b2, resolveMetadataRecord as b3, getPropertyIdForSchemaFileId as b4, getDataTypeFromString as b5, getMimeType as b6, listRelationStoragePropertyName as b7, PROPERTY_NAMES_EXEMPT_FROM_ID_SUFFIX_STRIP as b8, getAlternatePropertyNameForInstanceLookup as b9, BaseDb$1 as ba, ModelSchema as bb, BaseFileManager$1 as bc, SchemaSchema as bd, ModelSchemaSchema as be, resolveModelRecord$1 as bf, db as bg, download as bh, generateId$1 as bi, TPropertyDataType as c, TPropertyDefs as d, TStorageType as e, TValidationRules as f, normalizePropertyRecordSchema as g, appState as h, isDataType as i, arweaveL1FinalizeJobs as j, config as k, easSyncProcesses as l, metadata as m, normalizeDataType as n, htmlEmbeddedImageCoPublish as o, modelRelations as p, modelSchemas as q, modelUids as r, models as s, modelsRelations as t, properties as u, propertiesRelations as v, propertyUidRelations as w, propertyUids as x, publishProcesses as y, schemas as z };
+//# sourceMappingURL=BasePathResolver-CsZHPrk9.js.map