@absolutejs/artifacts 0.0.4 → 0.1.0

package/README.md

@@ -87,6 +87,27 @@ const history = await artifacts.listRevisions("owner-123", page.id);
 const restored = await artifacts.restore("owner-123", page.id, 1);
 ```
 
+## Production persistence
+
+Use the package-owned Drizzle schema on PostgreSQL, including Neon. The store
+atomically writes the current artifact, immutable revision, and lifecycle
+outbox events. It also persists per-revision indexing state and fences every
+artifact read and mutation by owner.
+
+```ts
+import {
+  artifactDrizzleSchema,
+  createDrizzleArtifactStore,
+} from "@absolutejs/artifacts/drizzle";
+
+const store = createDrizzleArtifactStore({ db });
+```
+
+Export `artifactDrizzleSchema` from your application's Drizzle schema so its
+normal migration workflow owns the four tables. Insert and select TypeBoxes
+generated directly from those tables are exported from the same entry point;
+hosts should reuse them instead of redefining database row schemas.
+
 ## File-backed artifact kinds
 
 Use the bundled definitions directly or compose them with application-specific

package/dist/drizzle.js

@@ -0,0 +1,245 @@
+// @bun
+// src/drizzle.ts
+import { and, asc, desc, eq, isNotNull, isNull } from "drizzle-orm";
+import {
+  customType,
+  index,
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-typebox";
+var recordJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var revisionJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var eventJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var indexingJsonb = customType({
+  dataType: () => "jsonb",
+  fromDriver: (value) => typeof value === "string" ? JSON.parse(value) : value,
+  toDriver: (value) => JSON.stringify(value)
+});
+var artifactRecords = pgTable("artifact_records", {
+  document: recordJsonb().notNull(),
+  id: text().primaryKey(),
+  kind: text().notNull(),
+  ownerId: text("owner_id").notNull(),
+  revision: integer().notNull(),
+  status: text().notNull(),
+  updatedAt: timestamp("updated_at", {
+    mode: "string",
+    withTimezone: true
+  }).notNull()
+}, (table) => [
+  index("artifact_records_owner_updated_idx").on(table.ownerId, table.updatedAt.desc()),
+  index("artifact_records_owner_kind_idx").on(table.ownerId, table.kind)
+]);
+var artifactRevisions = pgTable("artifact_revisions", {
+  artifactId: text("artifact_id").notNull().references(() => artifactRecords.id),
+  document: revisionJsonb().notNull(),
+  ownerId: text("owner_id").notNull(),
+  revision: integer().notNull()
+}, (table) => [
+  primaryKey({
+    columns: [table.artifactId, table.revision],
+    name: "artifact_revisions_pkey"
+  }),
+  index("artifact_revisions_owner_idx").on(table.ownerId, table.artifactId, table.revision.desc())
+]);
+var artifactEvents = pgTable("artifact_events", {
+  artifactId: text("artifact_id").notNull().references(() => artifactRecords.id),
+  createdAt: timestamp("created_at", {
+    mode: "string",
+    withTimezone: true
+  }).notNull(),
+  document: eventJsonb().notNull(),
+  id: text().primaryKey(),
+  ownerId: text("owner_id").notNull(),
+  processedAt: timestamp("processed_at", {
+    mode: "string",
+    withTimezone: true
+  }),
+  type: text().notNull()
+}, (table) => [
+  index("artifact_events_outbox_idx").on(table.processedAt, table.createdAt),
+  index("artifact_events_artifact_idx").on(table.ownerId, table.artifactId, table.createdAt)
+]);
+var artifactIndexingStates = pgTable("artifact_indexing_states", {
+  artifactId: text("artifact_id").primaryKey().references(() => artifactRecords.id),
+  document: indexingJsonb().notNull(),
+  ownerId: text("owner_id").notNull(),
+  revision: integer().notNull(),
+  status: text().notNull(),
+  updatedAt: timestamp("updated_at", {
+    mode: "string",
+    withTimezone: true
+  }).notNull()
+});
+var artifactDrizzleSchema = {
+  artifactEvents,
+  artifactIndexingStates,
+  artifactRecords,
+  artifactRevisions
+};
+var ArtifactRecordInsertSchema = createInsertSchema(artifactRecords);
+var ArtifactRecordSelectSchema = createSelectSchema(artifactRecords);
+var ArtifactRevisionInsertSchema = createInsertSchema(artifactRevisions);
+var ArtifactRevisionSelectSchema = createSelectSchema(artifactRevisions);
+var ArtifactEventInsertSchema = createInsertSchema(artifactEvents);
+var ArtifactEventSelectSchema = createSelectSchema(artifactEvents);
+var ArtifactIndexingStateInsertSchema = createInsertSchema(artifactIndexingStates);
+var ArtifactIndexingStateSelectSchema = createSelectSchema(artifactIndexingStates);
+var eventRows = (events) => events.map((event) => ({
+  artifactId: event.artifactId,
+  createdAt: event.createdAt,
+  document: event,
+  id: event.id,
+  ownerId: event.ownerId,
+  processedAt: event.processedAt,
+  type: event.type
+}));
+var assertEventsBelongToArtifact = (record, events) => {
+  if (events.some((event) => event.artifactId !== record.id || event.ownerId !== record.ownerId))
+    throw new Error("Artifact events must belong to the persisted artifact");
+};
+var recordRow = (record) => ({
+  document: record,
+  id: record.id,
+  kind: record.kind,
+  ownerId: record.ownerId,
+  revision: record.revision,
+  status: record.status,
+  updatedAt: record.updatedAt
+});
+var recordUpdate = (record) => ({
+  document: record,
+  kind: record.kind,
+  ownerId: record.ownerId,
+  revision: record.revision,
+  status: record.status,
+  updatedAt: record.updatedAt
+});
+var revisionRow = (record) => ({
+  artifactId: record.id,
+  document: record,
+  ownerId: record.ownerId,
+  revision: record.revision
+});
+var createDrizzleArtifactStore = (options) => ({
+  create: (record, events = []) => options.db.transaction(async (transaction) => {
+    assertEventsBelongToArtifact(record, events);
+    await transaction.insert(artifactRecords).values(recordRow(record));
+    await transaction.insert(artifactRevisions).values(revisionRow(record));
+    if (events.length > 0)
+      await transaction.insert(artifactEvents).values(eventRows(events));
+  }),
+  get: async (ownerId, artifactId) => {
+    const [row] = await options.db.select({ document: artifactRecords.document }).from(artifactRecords).where(and(eq(artifactRecords.id, artifactId), eq(artifactRecords.ownerId, ownerId))).limit(1);
+    return row?.document ?? null;
+  },
+  getIndexingState: async (ownerId, artifactId) => {
+    const [row] = await options.db.select({ document: artifactIndexingStates.document }).from(artifactIndexingStates).where(and(eq(artifactIndexingStates.artifactId, artifactId), eq(artifactIndexingStates.ownerId, ownerId))).limit(1);
+    return row?.document ?? null;
+  },
+  getRevision: async (ownerId, artifactId, revision) => {
+    const [row] = await options.db.select({ document: artifactRevisions.document }).from(artifactRevisions).where(and(eq(artifactRevisions.artifactId, artifactId), eq(artifactRevisions.ownerId, ownerId), eq(artifactRevisions.revision, revision))).limit(1);
+    return row?.document ?? null;
+  },
+  list: async (ownerId, query = {}) => {
+    const conditions = [eq(artifactRecords.ownerId, ownerId)];
+    if (query.kind)
+      conditions.push(eq(artifactRecords.kind, query.kind));
+    if (query.status)
+      conditions.push(eq(artifactRecords.status, query.status));
+    const statement = options.db.select({ document: artifactRecords.document }).from(artifactRecords).where(and(...conditions)).orderBy(desc(artifactRecords.updatedAt));
+    const rows = query.limit === undefined ? await statement : await statement.limit(query.limit);
+    return rows.map(({ document }) => document);
+  },
+  listEvents: async (query = {}) => {
+    const conditions = [];
+    if (query.processed !== undefined)
+      conditions.push(query.processed ? isNotNull(artifactEvents.processedAt) : isNull(artifactEvents.processedAt));
+    if (query.type)
+      conditions.push(eq(artifactEvents.type, query.type));
+    const statement = options.db.select({
+      document: artifactEvents.document,
+      processedAt: artifactEvents.processedAt
+    }).from(artifactEvents).where(conditions.length > 0 ? and(...conditions) : undefined).orderBy(asc(artifactEvents.createdAt));
+    const rows = query.limit === undefined ? await statement : await statement.limit(query.limit);
+    return rows.map(({ document, processedAt }) => ({
+      ...document,
+      ...processedAt ? { processedAt: new Date(processedAt).toISOString() } : {}
+    }));
+  },
+  listReferencedAssetIds: async () => {
+    const rows = await options.db.select({ document: artifactRevisions.document }).from(artifactRevisions);
+    return [
+      ...new Set(rows.flatMap(({ document }) => document.assets.map(({ id }) => id)))
+    ];
+  },
+  listRevisions: async (ownerId, artifactId) => (await options.db.select({ document: artifactRevisions.document }).from(artifactRevisions).where(and(eq(artifactRevisions.artifactId, artifactId), eq(artifactRevisions.ownerId, ownerId))).orderBy(desc(artifactRevisions.revision))).map(({ document }) => document),
+  markEventProcessed: async (eventId, processedAt) => (await options.db.update(artifactEvents).set({ processedAt }).where(eq(artifactEvents.id, eventId)).returning({ id: artifactEvents.id })).length === 1,
+  putIndexingState: (ownerId, state, events = []) => options.db.transaction(async (transaction) => {
+    assertEventsBelongToArtifact({ id: state.artifactId, ownerId }, events);
+    const [artifact] = await transaction.select({ id: artifactRecords.id }).from(artifactRecords).where(and(eq(artifactRecords.id, state.artifactId), eq(artifactRecords.ownerId, ownerId))).limit(1);
+    if (!artifact)
+      throw new Error("Artifact not found");
+    await transaction.insert(artifactIndexingStates).values({
+      artifactId: state.artifactId,
+      document: state,
+      ownerId,
+      revision: state.revision,
+      status: state.status,
+      updatedAt: state.updatedAt
+    }).onConflictDoUpdate({
+      set: {
+        document: state,
+        ownerId,
+        revision: state.revision,
+        status: state.status,
+        updatedAt: state.updatedAt
+      },
+      target: artifactIndexingStates.artifactId
+    });
+    if (events.length > 0)
+      await transaction.insert(artifactEvents).values(eventRows(events));
+  }),
+  save: (record, expectedRevision, events = []) => options.db.transaction(async (transaction) => {
+    assertEventsBelongToArtifact(record, events);
+    const updated = await transaction.update(artifactRecords).set(recordUpdate(record)).where(and(eq(artifactRecords.id, record.id), eq(artifactRecords.ownerId, record.ownerId), eq(artifactRecords.revision, expectedRevision))).returning({ id: artifactRecords.id });
+    if (updated.length !== 1)
+      return false;
+    await transaction.insert(artifactRevisions).values(revisionRow(record));
+    if (events.length > 0)
+      await transaction.insert(artifactEvents).values(eventRows(events));
+    return true;
+  })
+});
+export {
+  createDrizzleArtifactStore,
+  artifactRevisions,
+  artifactRecords,
+  artifactIndexingStates,
+  artifactEvents,
+  artifactDrizzleSchema,
+  ArtifactRevisionSelectSchema,
+  ArtifactRevisionInsertSchema,
+  ArtifactRecordSelectSchema,
+  ArtifactRecordInsertSchema,
+  ArtifactIndexingStateSelectSchema,
+  ArtifactIndexingStateInsertSchema,
+  ArtifactEventSelectSchema,
+  ArtifactEventInsertSchema
+};

package/dist/manifest.js

@@ -14,14 +14,23 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var defineManifest = () => (manifest) => {
-  const defined = manifest;
+var defineImplementation = () => (implementation) => {
+  const defined = implementation;
   return defined;
 };
-var toolFactory = () => ({
-  runtime: (definition) => ({ kind: "runtime", ...definition }),
-  workspace: (definition) => ({ kind: "workspace", ...definition })
-});
+var defineManifest = () => (manifest) => manifest;
+var literal = (value) => value;
+var RUNTIME_KIND = literal("runtime");
+var WORKSPACE_KIND = literal("workspace");
+var toolFactory = () => {
+  function runtime(definition) {
+    return { kind: RUNTIME_KIND, ...definition };
+  }
+  function workspace(definition) {
+    return { kind: WORKSPACE_KIND, ...definition };
+  }
+  return { runtime, workspace };
+};
 function IsAsyncIterator(value) {
   return IsObject(value) && globalThis.Symbol.asyncIterator in value;
 }
@@ -759,7 +768,7 @@ function String2(options) {
 function* FromUnion(syntax) {
   const trim = syntax.trim().replace(/"|'/g, "");
   return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt2() : trim === "string" ? yield String2() : yield (() => {
-    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+    const literals = trim.split("|").map((literal2) => Literal(literal2.trim()));
     return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
   })();
 }
@@ -3467,10 +3476,10 @@ function ScoreUnion(schema, references, value) {
     const keys = Object.getOwnPropertyNames(value);
     const entries = Object.entries(object.properties);
     return entries.reduce((acc, [key, schema2]) => {
-      const literal = schema2[Kind] === "Literal" && schema2.const === value[key] ? 100 : 0;
+      const literal2 = schema2[Kind] === "Literal" && schema2.const === value[key] ? 100 : 0;
       const checks = Check(schema2, references, value[key]) ? 10 : 0;
       const exists = keys.includes(key) ? 1 : 0;
-      return acc + (literal + checks + exists);
+      return acc + (literal2 + checks + exists);
     }, 0);
   } else if (schema[Kind] === "Union") {
     const schemas = schema.anyOf.map((schema2) => Deref(schema2, references));
@@ -5807,7 +5816,13 @@ var wiringSnippet = Type.Object({
     Type.Literal("server-plugin")
   ]))
 });
-var clientFrameworks = ["angular", "client", "react", "svelte", "vue"];
+var clientFrameworks = [
+  "angular",
+  "client",
+  "react",
+  "svelte",
+  "vue"
+];
 var wiringRecipe = Type.Object({
   client: Type.Optional(Type.Partial(Type.Object(Object.fromEntries(clientFrameworks.map((framework) => [framework, wiringSnippet]))))),
   description: Type.Optional(Type.String()),
@@ -5872,8 +5887,47 @@ var toolAnnotations = Type.Object({
   readOnlyHint: Type.Optional(Type.Boolean()),
   title: Type.Optional(Type.String())
 });
+var toolAuthorization = Type.Object({
+  approval: Type.Union([
+    Type.Literal("always"),
+    Type.Literal("never"),
+    Type.Literal("policy")
+  ]),
+  audience: Type.Union([
+    Type.Literal("admin"),
+    Type.Literal("authenticated"),
+    Type.Literal("owner"),
+    Type.Literal("public")
+  ]),
+  compensatingTool: Type.Optional(Type.String({ pattern: TOOL_NAME_PATTERN.source })),
+  destinationFields: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { minItems: 1 })),
+  destinations: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { minItems: 1 })),
+  effects: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+  idempotency: Type.Optional(Type.Union([
+    Type.Object({
+      field: Type.String({ minLength: 1 }),
+      mode: Type.Literal("field")
+    }),
+    Type.Object({ mode: Type.Literal("host") }),
+    Type.Object({ mode: Type.Literal("resource") })
+  ])),
+  requiredScopes: Type.Optional(Type.Array(Type.String({ minLength: 1 }), { minItems: 1 })),
+  resource: Type.Optional(Type.Object({
+    idField: Type.Optional(Type.String({ minLength: 1 })),
+    ownerIdField: Type.Optional(Type.String({ minLength: 1 })),
+    tenantIdField: Type.Optional(Type.String({ minLength: 1 })),
+    type: Type.String({ minLength: 1 })
+  })),
+  reversible: Type.Optional(Type.Boolean()),
+  spend: Type.Optional(Type.Object({
+    amountMinorField: Type.String({ minLength: 1 }),
+    currencyField: Type.String({ minLength: 1 }),
+    maximumAmountMinor: Type.Optional(Type.Integer({ minimum: 0 }))
+  }))
+});
 var serializedTool = Type.Object({
   annotations: Type.Optional(toolAnnotations),
+  authorization: Type.Optional(toolAuthorization),
   capabilities: Type.Optional(Type.Array(Type.Union([
     Type.Literal("exec"),
     Type.Literal("glob"),
@@ -5885,7 +5939,15 @@ var serializedTool = Type.Object({
   kind: Type.Union([Type.Literal("runtime"), Type.Literal("workspace")])
 });
 var manifestSchema = Type.Object({
-  contract: Type.Literal(1),
+  contract: Type.Union([Type.Literal(1), Type.Literal(2)]),
+  discovery: Type.Optional(Type.Object({
+    audiences: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    certificationUrl: Type.Optional(Type.String()),
+    intents: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    keywords: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    protocols: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
+    url: Type.Optional(Type.String())
+  })),
   identity: Type.Object({
     accent: Type.Optional(Type.String({ pattern: "^#[0-9a-fA-F]{3,8}$" })),
     category: Type.String({ minLength: 1 }),
@@ -5895,7 +5957,9 @@ var manifestSchema = Type.Object({
       svg: Type.Optional(Type.String()),
       url: Type.Optional(Type.String())
     })),
-    name: Type.String({ pattern: "^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9-~][a-z0-9-._~]*$" }),
+    name: Type.String({
+      pattern: "^(@[a-z0-9-~][a-z0-9-._~]*/)?[a-z0-9-~][a-z0-9-._~]*$"
+    }),
     tagline: Type.String({ minLength: 1 })
   }),
   implements: Type.Optional(Type.Array(adapterImplementation)),
@@ -5917,7 +5981,7 @@ var manifestSchema = Type.Object({
 import { Type as Type2 } from "@sinclair/typebox";
 var tool = toolFactory();
 var manifest = defineManifest()({
-  contract: 1,
+  contract: 2,
   identity: {
     accent: "#8b5cf6",
     category: "ai",
@@ -5926,19 +5990,80 @@ var manifest = defineManifest()({
     name: "@absolutejs/artifacts",
     tagline: "Give everything your AI makes a real lifecycle."
   },
+  implements: [
+    defineImplementation()({
+      contract: "artifacts/store",
+      factory: "createMemoryArtifactStore",
+      from: "@absolutejs/artifacts",
+      title: "In memory (development only \u2014 history resets on restart)",
+      wiring: {
+        code: "createMemoryArtifactStore()",
+        imports: [
+          {
+            from: "@absolutejs/artifacts",
+            names: ["createMemoryArtifactStore"]
+          }
+        ]
+      }
+    }),
+    defineImplementation()({
+      contract: "artifacts/store",
+      factory: "createDrizzleArtifactStore",
+      from: "@absolutejs/artifacts/drizzle",
+      requires: {
+        peers: [
+          {
+            name: "drizzle-orm",
+            range: ">=1.0.0-rc.4 <2",
+            reason: "Typed artifact revisions, indexing state, and transactional outbox persistence"
+          }
+        ],
+        services: [
+          {
+            description: "Artifact lifecycle and revision database",
+            id: "postgres"
+          }
+        ]
+      },
+      title: "Drizzle Postgres (production, including Neon)",
+      wiring: {
+        code: "createDrizzleArtifactStore({ db })",
+        imports: [
+          {
+            from: "@absolutejs/artifacts/drizzle",
+            names: ["createDrizzleArtifactStore"]
+          }
+        ]
+      }
+    })
+  ],
   settings: Type2.Object({}),
   slots: {
-    service: {
+    store: {
       configPath: "$self",
-      contract: "artifacts/service",
-      description: "The host-configured artifact service",
-      known: [],
+      contract: "artifacts/store",
+      description: "Where current artifacts, immutable revisions, indexing state, and transactional outbox events live",
+      known: [
+        "@absolutejs/artifacts#createMemoryArtifactStore",
+        "@absolutejs/artifacts#drizzle"
+      ],
       required: true
     }
   },
   tools: {
     artifact_get: tool.runtime({
       annotations: { readOnlyHint: true },
+      authorization: {
+        approval: "never",
+        audience: "owner",
+        effects: ["read"],
+        requiredScopes: ["artifacts:read"],
+        resource: {
+          idField: "artifactId",
+          ownerIdField: "ownerId",
+          type: "artifact"
+        }
+      },
       description: "Open one artifact owned by a user.",
       handler: async ({ artifactId, ownerId }, service) => JSON.stringify(await service.get(ownerId, artifactId)),
       input: Type2.Object({
@@ -5948,6 +6073,13 @@ var manifest = defineManifest()({
     }),
     artifact_list: tool.runtime({
       annotations: { readOnlyHint: true },
+      authorization: {
+        approval: "never",
+        audience: "owner",
+        effects: ["read"],
+        requiredScopes: ["artifacts:read"],
+        resource: { ownerIdField: "ownerId", type: "artifact" }
+      },
       description: "List artifacts owned by a user.",
       handler: async ({ kind, ownerId }, service) => JSON.stringify(await service.list(ownerId, { kind })),
       input: Type2.Object({
@@ -5957,6 +6089,17 @@ var manifest = defineManifest()({
     }),
     artifact_history: tool.runtime({
       annotations: { readOnlyHint: true },
+      authorization: {
+        approval: "never",
+        audience: "owner",
+        effects: ["read"],
+        requiredScopes: ["artifacts:read"],
+        resource: {
+          idField: "artifactId",
+          ownerIdField: "ownerId",
+          type: "artifact-revision"
+        }
+      },
       description: "List immutable revisions of one artifact owned by a user.",
       handler: async ({ artifactId, ownerId }, service) => JSON.stringify(await service.listRevisions(ownerId, artifactId)),
       input: Type2.Object({
@@ -5965,6 +6108,19 @@ var manifest = defineManifest()({
       })
     }),
     artifact_restore: tool.runtime({
+      authorization: {
+        approval: "policy",
+        audience: "owner",
+        effects: ["write"],
+        idempotency: { mode: "host" },
+        requiredScopes: ["artifacts:write"],
+        resource: {
+          idField: "artifactId",
+          ownerIdField: "ownerId",
+          type: "artifact-revision"
+        },
+        reversible: false
+      },
       description: "Restore an old artifact revision as a new private draft.",
       handler: async ({ artifactId, ownerId, revision }, service) => JSON.stringify(await service.restore(ownerId, artifactId, revision)),
       input: Type2.Object({
@@ -5988,7 +6144,7 @@ var manifest = defineManifest()({
           "\t}",
           "});",
           "",
-          "const artifactStore = createMemoryArtifactStore();",
+          "const artifactStore = ${slot.store};",
           "const artifactService = createArtifactService({",
           "\tregistry: artifactRegistry,",
           "\tstore: artifactStore",
@@ -5998,11 +6154,7 @@ var manifest = defineManifest()({
         imports: [
           {
             from: "@absolutejs/artifacts",
-            names: [
-              "createArtifactService",
-              "createMemoryArtifactStore",
-              "defineArtifactRegistry"
-            ]
+            names: ["createArtifactService", "defineArtifactRegistry"]
           },
           { from: "@sinclair/typebox", names: ["Type"] }
         ],