@0xobelisk/sui-common 1.2.0-pre.98 → 2.0.0

package/dist/index.js

@@ -1,10 +1,11 @@
-import Y from"prettier";import ke from"prettier-plugin-move-js";async function Ue(e,t){let s;t&&(s=await Y.resolveConfig(t));try{return Y.format(e,{plugins:[ke],parser:"move-parse",printWidth:120,semi:!0,tabWidth:2,useTabs:!1,bracketSpacing:!0,...s})}catch(n){let c;return n instanceof Error?c=n.message:c=n,console.log(`Error during output formatting: ${c}`),e}}async function N(e){return Y.format(e,{parser:"typescript"})}import G from"node:fs/promises";import te from"node:path";import ee from"debug";var R=ee("dubhe:common"),Se=ee("dubhe:common");R.log=console.debug.bind(console);Se.log=console.error.bind(console);var U=R.extend("codegen"),xe=R.extend("codegen");U.log=console.debug.bind(console);xe.log=console.error.bind(console);async function h(e,t,s){let n=e,c=`  // Copyright (c) Obelisk Labs, Inc.
-  // SPDX-License-Identifier: Apache-2.0
-  #[allow(unused_use)]
-  
-  /* Autogenerated file. Do not edit manually. */
-  
-  `,l="#[test_only]",S=c+n,D="#[allow(lint(share_owned))]";t.includes(".toml")||t.includes("system")||t.includes("migrate")?S=n:t.includes("init")?S=l+n:t.includes("genesis")&&(S=D+n),await G.mkdir(te.dirname(t),{recursive:!0}),await G.writeFile(t,S),U(`${s}: ${t}`)}async function Ne(e,t,s){let n=await N(e);await G.mkdir(te.dirname(t),{recursive:!0}),await G.writeFile(t,n),U(`${s}: ${t}`)}function tt(e){return e.replace(/\\/g,"/")}import{existsSync as K}from"fs";import P from"fs";function J(e){P.existsSync(e)&&(P.readdirSync(e).forEach(t=>{let s=`${e}/${t}`;P.lstatSync(s).isDirectory()?J(s):P.unlinkSync(s)}),P.rmdirSync(e))}var se={name:"@0xobelisk/sui-common",version:"1.2.0-pre.98",description:"Common low level logic shared between packages",keywords:["sui","obelisk labs","move","blockchain"],homepage:"https://github.com/0xobelisk/dubhe/tree/main/packages/sui-common#readme",bugs:"https://github.com/0xobelisk/dubhe/issues",repository:{type:"git",url:"https://github.com/0xobelisk/dubhe.git"},license:"Apache-2.0",author:"team@obelisk.build",type:"module",exports:{".":{types:"./dist/index.d.ts",default:"./dist/index.js"}},types:"./dist/index.d.ts",typesVersions:{"*":{index:["./src/index.ts"]}},scripts:{build:"pnpm run type-check && pnpm run build:js","build:js":"tsup && chmod +x ./dist/index.js",clean:"pnpm run clean:js","clean:js":"rimraf dist",dev:"tsup --watch",format:"prettier --write .","format:check":"prettier --check .",lint:"eslint . --ext .ts",test:"vitest","type-check":"tsc --noEmit",validate:"pnpm format:check && pnpm type-check"},dependencies:{chalk:"^5.0.1",debug:"^4.3.4",dotenv:"^16.0.3",ejs:"^3.1.8",esbuild:"^0.17.15",execa:"^7.0.0","find-up":"^6.3.0",glob:"^10.5.0",path:"^0.12.7",prettier:"^3.1.1","prettier-plugin-move-js":"^0.0.5","prettier-plugin-rust":"^0.1.9","prettier-plugin-solidity":"^1.1.2",typescript:"^5.8.3",yargs:"^17.7.1",zod:"^3.22.3","zod-validation-error":"^1.3.0"},devDependencies:{"@types/debug":"^4.1.12","@types/ejs":"^3.1.1","@types/glob":"^7.2.0","@types/node":"^22.16.0","@types/yargs":"^17.0.10",eslint:"^9.0.0","eslint-config-prettier":"^9.1.0",prettier:"3.3.3",tsup:"^6.7.0",tsx:"^3.12.6",vitest:"^2.1.3"},engines:{node:">=22.0.0"},publishConfig:{access:"public"}};async function ne(e,t){console.log(`
+import ye from"prettier";import Xe from"prettier-plugin-move-js";async function Rt(e,t){let s;t&&(s=await ye.resolveConfig(t));try{return ye.format(e,{plugins:[Xe],parser:"move-parse",printWidth:120,semi:!0,tabWidth:2,useTabs:!1,bracketSpacing:!0,...s})}catch(n){let r;return n instanceof Error?r=n.message:r=n,console.log(`Error during output formatting: ${r}`),e}}import ve from"node:fs/promises";import Ne from"node:path";import he from"debug";var ce=he("dubhe:common"),Qe=he("dubhe:common");ce.log=console.debug.bind(console);Qe.log=console.error.bind(console);var ue=ce.extend("codegen");ue.log=console.debug.bind(console);async function E(e,t,s){let n=e,r=`// Copyright (c) Obelisk Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/* Autogenerated file. Do not edit manually. */
+
+`,i=`#[test_only]
+`,d=r+n,l=`#[allow(lint(share_owned))]
+`;t.includes(".toml")||t.includes("system")||t.includes("migrate")?d=n:t.includes("init_test")?d=i+n:t.includes("genesis")&&(d=l+n),await ve.mkdir(Ne.dirname(t),{recursive:!0}),await ve.writeFile(t,d),ue(`${s}: ${t}`)}import{existsSync as q}from"fs";import X from"fs";function pe(e){X.existsSync(e)&&(X.readdirSync(e).forEach(t=>{let s=`${e}/${t}`;X.lstatSync(s).isDirectory()?pe(s):X.unlinkSync(s)}),X.rmdirSync(e))}var ke={name:"@0xobelisk/sui-common",version:"2.0.0",description:"Common low level logic shared between packages",keywords:["sui","obelisk labs","move","blockchain"],homepage:"https://github.com/0xobelisk/dubhe/tree/main/packages/sui-common#readme",bugs:"https://github.com/0xobelisk/dubhe/issues",repository:{type:"git",url:"https://github.com/0xobelisk/dubhe.git"},license:"Apache-2.0",author:"team@obelisk.build",type:"module",exports:{".":{types:"./dist/index.d.ts",default:"./dist/index.js"}},types:"./dist/index.d.ts",typesVersions:{"*":{index:["./src/index.ts"]}},scripts:{build:"pnpm run type-check && pnpm run build:js","build:js":"tsup && chmod +x ./dist/index.js",clean:"pnpm run clean:js","clean:js":"rimraf dist",dev:"tsup --watch",format:"prettier --write .","format:check":"prettier --check .",lint:"eslint . --ext .ts",test:"vitest","type-check":"tsc --noEmit",validate:"pnpm format:check && pnpm type-check"},dependencies:{chalk:"^5.0.1",debug:"^4.3.4",dotenv:"^16.0.3",ejs:"^3.1.8",esbuild:"^0.17.15",execa:"^7.0.0","find-up":"^6.3.0",glob:"^10.5.0",path:"^0.12.7",prettier:"^3.1.1","prettier-plugin-move-js":"^0.0.5",typescript:"^5.8.3",yargs:"^17.7.1",zod:"^3.22.3","zod-validation-error":"^1.3.0"},devDependencies:{"@types/debug":"^4.1.12","@types/ejs":"^3.1.1","@types/glob":"^7.2.0","@types/node":"^22.16.0","@types/yargs":"^17.0.10",eslint:"^9.0.0","eslint-config-prettier":"^9.1.0",prettier:"3.3.3",tsup:"^6.7.0",tsx:"^3.12.6",vitest:"^2.1.3"},engines:{node:">=22.0.0"},publishConfig:{access:"public"}};async function Se(e,t){console.log(`
 \u{1F4C4} Starting Move.toml Generation...`),console.log(`  \u2514\u2500 Output path: ${t}/src/${e.name}/Move.toml`);let s=`[package]
 name = "${e.name}"
 version = "1.0.0"
@@ -12,627 +13,1243 @@ edition = "2024"
 
 [dependencies]
 Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "mainnet-v1.46.3" }
-Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", subdir = "framework/src/dubhe", rev = "v${se.version}" }
+Dubhe = { git = "https://github.com/0xobelisk/dubhe.git", subdir = "framework/src/dubhe", rev = "v${ke.version}" }
 
 [addresses]
 sui = "0x2"
 ${e.name} = "0x0"
-`;await h(s,`${t}/src/${e.name}/Move.toml`,"formatAndWriteMove"),console.log(`\u2705 Move.toml Generation Complete
-`)}import{existsSync as re}from"fs";async function ue(e,t){if(!re(t)){let s=`module ${e.name}::deploy_hook {
-			  use dubhe::dapp_service::DappHub;
-
-  public(package) fun run(_dapp_hub: &mut DappHub, _ctx: &mut TxContext) {
-
-  }
-}`;await h(s,t,"formatAndWriteMove")}}async function ie(e,t){if(!re(`${t}/src/${e.name}/sources/scripts/migrate.move`)){let s=`module ${e.name}::migrate {
+`;await E(s,`${t}/src/${e.name}/Move.toml`,"formatAndWriteMove"),console.log(`\u2705 Move.toml Generation Complete
+`)}import{existsSync as xe}from"fs";async function Ce(e,t,s=1){if(!xe(t)){let n=s===1?`// Settlement mode: USER_PAYS \u2014 users pay transaction fees at settlement time.
+    // The framework admin sets the revenue share via set_dapp_revenue_share.
+    // Initialise any DappStorage-level defaults here (e.g. resource starting values).`:`// Settlement mode: DAPP_SUBSIDIZES \u2014 the DApp pays for user operations.
+    // Recharge the credit pool via dapp_system::recharge_credit before users can write.
+    // Initialise any DappStorage-level defaults here (e.g. resource starting values).`,r=`module ${e.name}::deploy_hook {
+    use dubhe::dapp_service::DappStorage;
+
+    public(package) fun run(_dapp_storage: &mut DappStorage, _ctx: &mut TxContext) {
+        ${n}
+    }
+}`;await E(r,t,"formatAndWriteMove")}}async function we(e,t){if(!xe(`${t}/src/${e.name}/sources/scripts/migrate.move`)){let s=`module ${e.name}::migrate {
     const ON_CHAIN_VERSION: u32 = 1;
 
     public fun on_chain_version(): u32 {
         ON_CHAIN_VERSION
     }
 }
-`;await h(s,`${t}/src/${e.name}/sources/scripts/migrate.move`,"formatAndWriteMove")}}async function oe(e,t){let s=`module ${e.name}::dapp_key {
-use std::type_name;
-  use sui::address;
-  use std::ascii::String;
+`;await E(s,`${t}/src/${e.name}/sources/scripts/migrate.move`,"formatAndWriteMove")}}async function De(e,t){let s=`module ${e.name}::dapp_key {
+    use std::type_name;
+    use sui::address;
+    use std::ascii::String;
+
+    /// DappKey \u2014 package-level authorization token for this DApp.
+    ///
+    /// SECURITY: \`new()\` is intentionally \`public(package)\`.
+    /// Only code compiled into this package can construct a DappKey instance.
+    /// All framework write functions (\`set_record\`, \`set_field\`,
+    /// \`take_record\`, \`create_user_storage\`, \u2026) require \`_auth: DappKey\`
+    /// as proof that the call originated from inside this package \u2014 an
+    /// external PTB cannot fabricate that proof.
+    ///
+    /// NEVER change \`new()\` to \`public\`, and never accept a DappKey
+    /// value as a parameter from an external caller.  Either mistake removes
+    /// every package-level access guard, allowing any PTB to write arbitrary
+    /// user data or register UserStorages without going through the DApp's
+    /// own entry functions.
+
+    public struct DappKey has copy, drop {}
+
+    /// Constructs an authorization token. Callable only from within this package.
+    /// Pass the result as \`_auth\` to any framework function that requires it.
+    public(package) fun new(): DappKey {
+        DappKey {}
+    }
 
-  /// Authorization token for the app.
+    public fun to_string(): String {
+        type_name::with_defining_ids<DappKey>().into_string()
+    }
 
-  public struct DappKey has copy, drop {}
+    public fun package_id(): address {
+        let package_id_str = type_name::with_defining_ids<DappKey>().address_string();
+        address::from_ascii_bytes(package_id_str.as_bytes())
+    }
 
-  public(package) fun new(): DappKey {
-    DappKey {  }
-  }
+    public fun eq<DappKey1: copy + drop, DappKey2: copy + drop>(_: &DappKey1, _: &DappKey2): bool {
+        type_name::with_defining_ids<DappKey1>() == type_name::with_defining_ids<DappKey2>()
+    }
+}
+`;await E(s,t,"formatAndWriteMove")}import{existsSync as je}from"fs";import Te from"node:fs/promises";async function Ae(e,t){je(`${t}/src/${e.name}/sources/systems`)||await Te.mkdir(`${t}/src/${e.name}/sources/systems`,{recursive:!0}),je(`${t}/src/${e.name}/sources/tests`)||await Te.mkdir(`${t}/src/${e.name}/sources/tests`,{recursive:!0})}function tt(e){return"E"+e.split("_").map(t=>t.charAt(0).toUpperCase()+t.slice(1)).join("")}function st(e){return typeof e=="string"?e:e.message}async function Ee(e,t,s){console.log(`
+\u{1F4E6} Starting Error Generation...`);let n=Object.entries(t).map(([i,d])=>{let l=tt(i),u=st(d);return console.log(`     \u2514\u2500 ${i}: ${u}`),["    #[error]",`    const ${l}: vector<u8> = b"${u}";`,`    public fun ${i}(condition: bool) { assert!(condition, ${l}) }`].join(`
+`)}).join(`
 
-  public fun to_string(): String {
-    type_name::get<DappKey>().into_string()
+`),r=`module ${e}::error {
+${n}
+}
+`;await E(r,`${s}/src/${e}/sources/codegen/error.move`,"formatAndWriteMove")}async function Oe(e,t){let n=e.name==="dubhe"?"":`
+  /// Create a DappStorage for this DApp without sharing it.
+  /// Suitable for unit tests that exercise global-resource functions.
+  public fun create_dapp_storage_for_testing(ctx: &mut TxContext): dubhe::dapp_service::DappStorage {
+    dubhe::dapp_system::create_dapp_storage_for_testing<${e.name}::dapp_key::DappKey>(ctx)
   }
 
-  public fun package_id(): address {
-    let package_id_str = type_name::get<DappKey>().get_address();
-    address::from_ascii_bytes(package_id_str.as_bytes())
-  }
+  /// Create a UserStorage for \`owner\` without sharing it.
+  /// Suitable for unit tests that exercise user-level resource functions.
+  public fun create_user_storage_for_testing(owner: address, ctx: &mut TxContext): dubhe::dapp_service::UserStorage {
+    dubhe::dapp_system::create_user_storage_for_testing<${e.name}::dapp_key::DappKey>(owner, ctx)
+  }`,r=`
+module ${e.name}::init_test {
+  use dubhe::dapp_system;
 
-  public fun eq<DappKey1: copy + drop, DappKey2: copy + drop>(_: &DappKey1, _: &DappKey2): bool {
-    type_name::get<DappKey1>() == type_name::get<DappKey2>()
+  /// Create a DappHub for testing without sharing it.
+  /// Suitable for unit tests that need a DappHub context.
+  public fun create_dapp_hub_for_testing(ctx: &mut TxContext): dubhe::dapp_service::DappHub {
+    dapp_system::create_dapp_hub_for_testing(ctx)
   }
+${n}
 }
-`;await h(s,t,"formatAndWriteMove")}import{existsSync as ce}from"fs";import pe from"node:fs/promises";async function ae(e,t){ce(`${t}/src/${e.name}/sources/systems`)||await pe.mkdir(`${t}/src/${e.name}/sources/systems`,{recursive:!0}),ce(`${t}/src/${e.name}/sources/tests`)||await pe.mkdir(`${t}/src/${e.name}/sources/tests`,{recursive:!0})}async function le(e,t,s){console.log(`
-\u{1F4E6} Starting Schema Error Generation...`);let n=`module ${e}::errors {
-		${Object.entries(t).map(([c,l])=>(console.log(`     \u2514\u2500 ${c}: ${l}`),`#[error]
-				const ${c.toUpperCase()}: vector<u8> = b"${l}";
-				public fun ${c}_error(condition: bool) { assert!(condition, ${c.toUpperCase()})  }
-		`)).join(`
-`)}
-            }`;await h(n,`${s}/src/${e}/sources/codegen/errors.move`,"formatAndWriteMove")}async function _e(e,t){let s=`module ${e.name}::init_test {
-  use sui::clock;
-  use sui::test_scenario;
-  use sui::test_scenario::Scenario;
-  use dubhe::dapp_service::DappHub;
-  use dubhe::dapp_system;
+`;await E(r,t,"formatAndWriteMove")}async function Fe(e,t,s=1){let r=e.name==="dubhe"?`module ${e.name}::genesis {
+    use dubhe::dapp_service::DappHub;
+
+    // The framework genesis initialises the DappHub state via deploy_hook.
+    // No DappStorage is created for the framework itself \u2014 the framework is
+    // infrastructure, not a DApp.
+    public fun run(dapp_hub: &mut DappHub, ctx: &mut TxContext) {
+        ${e.name}::deploy_hook::run(dapp_hub, ctx);
+    }
 
-  public fun deploy_dapp_for_testing(scenario: &mut Scenario): DappHub {
-    let ctx = test_scenario::ctx(scenario);
-    let clock = clock::create_for_testing(ctx);
-    let mut dapp_hub = dapp_system::create_dapp_hub_for_testing(ctx);
-    ${e.name!="dubhe"?"dubhe::genesis::run(&mut dapp_hub, &clock, ctx);":""}
-    ${e.name}::genesis::run(&mut dapp_hub, &clock, ctx);
-    clock::destroy_for_testing(clock);
-    test_scenario::next_tx(scenario, ctx.sender());
-    dapp_hub
-  }
+    // Called during framework upgrades to run any custom migration logic.
+    // \`dubhe upgrade\` rewrites the region between the separator comments.
+    public(package) fun migrate(_dapp_hub: &mut DappHub, _ctx: &mut TxContext) {
+        // ==========================================
+        // Add custom migration logic here.
+        // ==========================================
+    }
 }
-`;await h(s,t,"formatAndWriteMove")}function x(e){return e==="dubhe"?"dapp_service":"dapp_system"}async function Z(e,t){console.log(`
-\u{1F4E6} Starting Components Generation...`);for(let[s,n]of Object.entries(e.components)){if(console.log(`     \u2514\u2500 ${s}: ${JSON.stringify(n)}`),typeof n=="string"){let l=Ce(e.name,s,n,"Onchain");await h(l,`${t}/${s}.move`,"formatAndWriteMove");continue}if(Object.keys(n).length===0){let l=de(e.name,s,{fields:{entity_id:"address"},keys:["entity_id"],offchain:!1});await h(l,`${t}/${s}.move`,"formatAndWriteMove");continue}if(n.keys||(n.keys=["entity_id"],n.fields.entity_id||(n.fields={entity_id:"address",...n.fields})),n.keys&&n.keys.length>1)throw new Error(`Component '${s}' can only have one key, but found ${n.keys.length} keys: ${n.keys.join(", ")}`);let c=de(e.name,s,n);await h(c,`${t}/${s}.move`,"formatAndWriteMove")}}function Ce(e,t,s,n="Onchain"){let c=!T(s),l=c?`${be(s)}`:"";return`module ${e}::${t} { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
+`:`module ${e.name}::genesis {
+    use sui::clock::Clock;
+    use dubhe::dapp_service::{DappHub, DappStorage};
+    use ${e.name}::dapp_key;
     use dubhe::dapp_system;
-    use ${e}::dapp_key;
-    use ${e}::dapp_key::DappKey;
-${c&&s!=="string"&&s!=="String"?`    use ${e}::${l};
-    use ${e}::${l}::{${s}};`:""}
+    use std::ascii::string;
 
-    const TABLE_NAME: vector<u8> = b"${t}";
-    const TABLE_TYPE: vector<u8> = b"Component";
-    const OFFCHAIN: bool = ${n==="Offchain"};
+    // The one-shot guard is enforced inside dapp_system::create_dapp, which
+    // records the DappKey type in DappHub before returning DappStorage.
+    // genesis.move does not need to carry its own guard.
+    public fun run(dapp_hub: &mut DappHub, clock: &Clock, ctx: &mut TxContext) {
+        // create_dapp aborts with dapp_already_initialized_error on repeated calls.
+        let dapp_key = dapp_key::new();
+        let mut ds = dapp_system::create_dapp(dapp_key, dapp_hub, string(b"${e.name}"), string(b"${e.description}"), ${s}, clock, ctx);
 
-    public fun get_table_id(): String {
-        string(TABLE_NAME)
+        // Set up initial DApp state (e.g. default resource values).
+        ${e.name}::deploy_hook::run(&mut ds, ctx);
+
+        // Share DappStorage so every transaction can access it.
+        transfer::public_share_object(ds);
     }
 
-    public fun get_key_schemas(): vector<String> { 
-        vector[string(b"address")]
+    // Called during contract upgrades to register newly added resource tables
+    // and run any custom migration logic. \`dubhe upgrade\` rewrites the region
+    // between the separator comments; do not edit that block manually.
+    public(package) fun migrate(_dapp_hub: &mut DappHub, _dapp_storage: &mut DappStorage, _ctx: &mut TxContext) {
+        // ==========================================
+        // Add custom migration logic here (e.g. initialise new resource defaults).
+        // migrate_to_vN in migrate.move calls this function automatically.
+        // ==========================================
     }
+}
+`;await E(r,t,"formatAndWriteMove")}function Ke(e){return e.replace(/[A-Z]/g,t=>`_${t.toLowerCase()}`).replace(/^_/,"")}async function Ie(e,t){if(console.log(`
+\u{1F4E6} Starting Enums Generation...`),!!e.enums)for(let[s,n]of Object.entries(e.enums)){console.log(`     \u2514\u2500 ${s}: ${JSON.stringify(n)}`);let r=[...n].sort((d,l)=>d.localeCompare(l)),i=rt(e.name,s,r);await E(i,`${t}/${Ke(s)}.move`,"formatAndWriteMove")}}function rt(e,t,s){let n=s.map(r=>r.charAt(0).toUpperCase()+r.slice(1)).join(",");return`module ${e}::${Ke(t)} {
+    use sui::bcs::{BCS, to_bytes, peel_enum_tag};
 
-    public fun get_value_schemas(): vector<String> { 
-        vector[string(b"${s}")]
+    public enum ${t} has copy, drop, store {
+        ${n}
     }
 
-    public fun get_key_names(): vector<String> { 
-        vector[string(b"entity_id")]
+${s.map(r=>`    public fun new_${r.toLowerCase()}(): ${t} {
+        ${t}::${r.charAt(0).toUpperCase()+r.slice(1)}
+    }`).join(`
+
+`)}
+
+    public fun encode(self: ${t}): vector<u8> {
+        to_bytes(&self)
     }
 
-    public fun get_value_names(): vector<String> { 
-        vector[string(b"value")]
+    public fun decode(bytes: &mut BCS): ${t} {
+        match(peel_enum_tag(bytes)) {
+${s.map((r,i)=>`            ${i} => ${t}::${r.charAt(0).toUpperCase()+r.slice(1)},`).join(`
+`)}
+            _ => abort,
+        }
+    }
+}`}function Me(e){return e==="dubhe"?"dapp_service":"dapp_system"}function R(e){return e!=="dubhe"?"dapp_key::new(), ":""}function z(e,t){return""}function H(e,t){return""}function Pe(e){return e?"DappStorage":"UserStorage"}function Re(e){return e?"dapp_storage":"user_storage"}function le(e,t){let s=Me(e);return t?{set_record:`${s}::set_global_record`,set_field:`${s}::set_global_field`,get_field:`${s}::get_global_field`,has_record:`${s}::has_global_record`,ensure_has:`${s}::ensure_has_global_record`,ensure_has_not:`${s}::ensure_has_not_global_record`,delete_record:`${s}::delete_global_record`,delete_field:`${s}::delete_global_field`}:{set_record:`${s}::set_record`,set_field:`${s}::set_field`,get_field:`${s}::get_field`,has_record:`${s}::has_record`,ensure_has:`${s}::ensure_has_record`,ensure_has_not:`${s}::ensure_has_not_record`,delete_record:`${s}::delete_record`,delete_field:`${s}::delete_field`}}async function Le(e,t){if(console.log(`
+\u{1F4E6} Starting Resources Generation...`),!!e.resources)for(let[s,n]of Object.entries(e.resources)){if(console.log(`     \u2514\u2500 ${s}: ${JSON.stringify(n)}`),typeof n=="string"){let l=nt(e.name,s,n,"Onchain");await E(l,`${t}/${s}.move`,"formatAndWriteMove");continue}if(!n.fields||Object.keys(n.fields).length===0)throw new Error(`Resource '${s}' must have fields defined, but found empty object`);n.keys||(n.keys=[]);let r=ot(e.name,s,n),i=at(e,s,n),d=i?r.replace(/^}$/m,`
+${i}
+}`):r;await E(d,`${t}/${s}.move`,"formatAndWriteMove")}}function nt(e,t,s,n="Onchain"){let r=!B(s),i=r?`${de(s)}`:"",d=n==="Offchain",l=!1,u=Pe(l),_=Re(l),g=le(e,l),y=d?"":`
+    public fun has(${_}: &${u}): bool {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        ${g.has_record}<DappKey>(${_}, key_tuple)
     }
 
-    public(package) fun register_table(dapp_hub: &mut DappHub, ctx: &mut TxContext) {
-        let dapp_key = dapp_key::new();
-        ${x(e)}::register_table(
-            dapp_hub, 
-            dapp_key,
-            string(TABLE_TYPE),
-            get_table_id(), 
-            get_key_schemas(), 
-            get_key_names(), 
-            get_value_schemas(), 
-            get_value_names(), 
-            OFFCHAIN,
-            ctx
-        );
+    public fun ensure_has(${_}: &${u}) {
+        let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        ${g.ensure_has}<DappKey>(${_}, key_tuple)
     }
 
-    public fun has(dapp_hub: &DappHub, entity_id: address): bool {
+    public fun ensure_has_not(${_}: &${u}) {
         let mut key_tuple = vector::empty();
-        key_tuple.push_back(to_bytes(&entity_id));
-        ${x(e)}::has_record<DappKey>(dapp_hub, get_table_id(), key_tuple)
+        key_tuple.push_back(TABLE_NAME);
+        ${g.ensure_has_not}<DappKey>(${_}, key_tuple)
     }
 
-    public(package) fun delete(dapp_hub: &mut DappHub, entity_id: address) {
+    public(package) fun delete(${_}: &mut ${u}, ctx: &TxContext) {
         let mut key_tuple = vector::empty();
-        key_tuple.push_back(to_bytes(&entity_id));
-        ${x(e)}::delete_record<DappKey>(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, OFFCHAIN);
+        key_tuple.push_back(TABLE_NAME);
+        ${g.delete_record}<DappKey>(${R(e)}${_}, key_tuple, vector[b"value"], ctx);
     }
 
-    public fun get(dapp_hub: &DappHub, entity_id: address): (${s==="string"||s==="String"?"String":s}) {
+    public fun get(${_}: &${u}): (${s==="string"||s==="String"?"String":s}) {
         let mut key_tuple = vector::empty();
-        key_tuple.push_back(to_bytes(&entity_id));
-        let value_tuple = ${x(e)}::get_record<DappKey>(dapp_hub, get_table_id(), key_tuple);
-        let mut bsc_type = sui::bcs::new(value_tuple);
-        ${s==="string"||s==="String"?"let value = dubhe::bcs::peel_string(&mut bsc_type);":s==="vector<String>"?"let value = dubhe::bcs::peel_vec_string(&mut bsc_type);":c?`let value = ${e}::${l}::decode(&mut bsc_type);`:`let value = sui::bcs::peel_${L(s)}(&mut bsc_type);`}
+        key_tuple.push_back(TABLE_NAME);
+        let value_raw = ${g.get_field}<DappKey>(${_}, key_tuple, b"value");
+        let mut value_bcs = sui::bcs::new(value_raw);
+        let value = ${J(e,s,"value_bcs",r?[{type:s,module:i}]:[])};
         (value)
     }
+`,o=l?"use dubhe::dapp_service::DappStorage;":"use dubhe::dapp_service::UserStorage;",b=r&&s!=="string"&&s!=="String";return`module ${e}::${t} {${!b?`
+    use sui::bcs::{to_bytes};`:""}${s==="string"||s==="String"?`
+    use std::ascii::{String, into_bytes};`:s==="vector<String>"?`
+    use std::ascii::String;`:""}
+    ${o}
+    use dubhe::dapp_system;
+    use ${e}::dapp_key;
+    use ${e}::dapp_key::DappKey;
+${b?`    use ${e}::${i}::{${s}};`:""}
 
-    public(package) fun set(dapp_hub: &mut DappHub, entity_id: address, value: ${s==="string"||s==="String"?"String":s}) {
+    const TABLE_NAME: vector<u8> = b"${t}";
+    const OFFCHAIN: bool = ${n==="Offchain"};
+
+${y}
+    public(package) fun set(${H(e,l)}${_}: &mut ${u}, value: ${s==="string"||s==="String"?"String":s}, ctx: &mut TxContext) {
         let mut key_tuple = vector::empty();
-        key_tuple.push_back(to_bytes(&entity_id));
+        key_tuple.push_back(TABLE_NAME);
+        let field_names = vector[b"value"];
         let value_tuple = encode(value);
-        ${x(e)}::set_record(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, value_tuple, OFFCHAIN);
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN, ctx);
     }
 
     public fun encode(value: ${s==="string"||s==="String"?"String":s}): vector<vector<u8>> {
         let mut value_tuple = vector::empty();
-        value_tuple.push_back(${s==="string"||s==="String"?"to_bytes(&into_bytes(value))":s==="vector<String>"?"to_bytes(&value)":c?`${e}::${l}::encode(value)`:"to_bytes(&value)"});
+        value_tuple.push_back(${s==="string"||s==="String"?"to_bytes(&into_bytes(value))":s==="vector<String>"?"to_bytes(&value)":r?`${e}::${i}::encode(value)`:"to_bytes(&value)"});
         value_tuple
     }
-}`}function be(e){return e.replace(/[A-Z]/g,t=>`_${t.toLowerCase()}`).replace(/^_/,"")}function de(e,t,s){let n=s.fields,c=s.keys||["entity_id"],S=s.offchain||!1?"Offchain":"Onchain",D=Object.keys(n).every(p=>c.includes(p)),$=Object.entries(n).filter(([p])=>!c.includes(p)).map(([p])=>p),v=$.length===1,C=Object.entries(n).filter(([p,A])=>!T(A)&&A!=="string"&&A!=="String").map(([p,A])=>({type:A,module:`${be(A)}`})).filter((p,A,a)=>a.findIndex(w=>w.type===p.type)===A),O=Oe(e,t,n,c,!D&&!v,C,S);if(D||v)return`module ${e}::${t} { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
+}`}function de(e){return e.replace(/[A-Z]/g,t=>`_${t.toLowerCase()}`).replace(/^_/,"")}function ot(e,t,s){let n=s.fields,r=s.keys||[],i=s.offchain||!1,d=s.global||!1,l=i?"Offchain":"Onchain",u=d,_=Pe(u),g=Re(u),y=le(e,u),o=Object.keys(n).every(m=>r.includes(m)),b=Object.entries(n).filter(([m])=>!r.includes(m)),p=b.map(([m])=>m),h=p.length===1,a=b.filter(([m,C])=>!B(C)&&C!=="string"&&C!=="String").map(([m,C])=>({type:C,module:`${de(C)}`})).filter((m,C,W)=>W.findIndex(Y=>Y.type===m.type)===C),$=Object.entries(n).filter(([m,C])=>!B(C)&&C!=="string"&&C!=="String").map(([m,C])=>({type:C,module:`${de(C)}`})).filter((m,C,W)=>W.findIndex(Y=>Y.type===m.type)===C),x=it(e,t,n,r,!o&&!h,a,l,u,_,g,y),k=u?"use dubhe::dapp_service::DappStorage;":s.listable?"use dubhe::dapp_service::{UserStorage, DappStorage};":"use dubhe::dapp_service::UserStorage;",T=s.reactive?`
+    use dubhe::dapp_service::ScenePermit;`:"",w=Object.values(n),A=p.filter(m=>{let C=n[m];return B(C)||C==="string"||C==="String"}).length>0||r.length>0?`
+    use sui::bcs::{to_bytes};`:"",D=w.some(m=>m==="string"||m==="String"),v=w.some(m=>m==="vector<String>"),K=p.some(m=>{let C=n[m];return C==="string"||C==="String"}),P=K?`
+    use std::ascii::{String, into_bytes};`:D||v?`
+    use std::ascii::String;`:"",c=K?`
+    use std::ascii::{string, String, into_bytes};`:D||v?`
+    use std::ascii::String;`:"";if(o||h)return`module ${e}::${t} {${A}${P}
+    ${k}${T}
     use dubhe::dapp_system;
     use ${e}::dapp_key;
     use ${e}::dapp_key::DappKey;
-${C.length>0?C.map(p=>`    use ${e}::${p.module};
-    use ${e}::${p.module}::{${p.type}};`).join(`
+${$.length>0?$.map(m=>`    use ${e}::${m.module}::{${m.type}};`).join(`
 `):""}
 
     const TABLE_NAME: vector<u8> = b"${t}";
-    const TABLE_TYPE: vector<u8> = b"Component";
-    const OFFCHAIN: bool = ${S==="Offchain"};
-${O}
-}`;let i=$.map(p=>`        ${p}: ${n[p]==="string"||n[p]==="String"?"String":n[p]==="vector<String>"?"vector<String>":n[p]},`).join(`
-`),g=$.map(p=>`${p}: ${n[p]==="string"||n[p]==="String"?"String":n[p]==="vector<String>"?"vector<String>":n[p]}`).join(", "),b=$.map(p=>`            ${p},`).join(`
-`),f=$.map(p=>`    public fun ${p}(self: &${j(t)}): ${n[p]==="string"||n[p]==="String"?"String":n[p]==="vector<String>"?"vector<String>":n[p]} {
-        self.${p}
+    const OFFCHAIN: bool = ${i};
+
+${x}
+}`;let f=p.map(m=>`        ${m}: ${n[m]==="string"||n[m]==="String"?"String":n[m]==="vector<String>"?"vector<String>":n[m]},`).join(`
+`),S=p.map(m=>`${m}: ${n[m]==="string"||n[m]==="String"?"String":n[m]==="vector<String>"?"vector<String>":n[m]}`).join(", "),j=p.map(m=>`            ${m},`).join(`
+`),M=p.map(m=>`    public fun ${m}(self: &${I(t)}): ${n[m]==="string"||n[m]==="String"?"String":n[m]==="vector<String>"?"vector<String>":n[m]} {
+        self.${m}
     }`).join(`
 
-`),m=$.map(p=>`    public fun update_${p}(self: &mut ${j(t)}, ${p}: ${n[p]==="string"||n[p]==="String"?"String":n[p]==="vector<String>"?"vector<String>":n[p]}) {
-        self.${p} = ${p}
+`),ee=p.map(m=>`    public fun update_${m}(self: &mut ${I(t)}, ${m}: ${n[m]==="string"||n[m]==="String"?"String":n[m]==="vector<String>"?"vector<String>":n[m]}) {
+        self.${m} = ${m}
     }`).join(`
 
-`);return`module ${e}::${t} { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
+`);return`module ${e}::${t} {${A}${c}
+    ${k}${T}
     use dubhe::dapp_system;
     use ${e}::dapp_key;
     use ${e}::dapp_key::DappKey;
-${C.length>0?C.map(p=>`    use ${e}::${p.module};
-    use ${e}::${p.module}::{${p.type}};`).join(`
+${$.length>0?$.map(m=>`    use ${e}::${m.module}::{${m.type}};`).join(`
 `):""}
 
     const TABLE_NAME: vector<u8> = b"${t}";
-    const TABLE_TYPE: vector<u8> = b"Component";
-    const OFFCHAIN: bool = ${S==="Offchain"};
-
-    public struct ${j(t)} has copy, drop, store {
-${i}
-    }
-
-    public fun new(${g}): ${j(t)} {
-        ${j(t)} {
-${b}
-        }
-    }
+    const OFFCHAIN: bool = ${i};
 
+    public struct ${I(t)} has copy, drop, store {
 ${f}
-
-${m}
-
-${O}
-}`}function T(e){return["address","bool","u8","u16","u32","u64","u128","u256","string","String","vector<address>","vector<bool>","vector<u8>","vector<u16>","vector<u32>","vector<u64>","vector<u128>","vector<u256>","vector<String>","vector<vector<address>>","vector<vector<bool>>","vector<vector<u8>>","vector<vector<u16>>","vector<vector<u32>>","vector<vector<u64>>","vector<vector<u128>>","vector<vector<u256>>"].includes(e)}function Oe(e,t,s,n,c=!0,l=[],S="Onchain"){let D=n.reduce((u,y)=>({...u,[y]:s[y]}),{}),o=Object.entries(s).filter(([u])=>!n.includes(u)).reduce((u,[y,r])=>({...u,[y]:r}),{}),$=Object.keys(D),v=Object.keys(o),C=Object.keys(s).every(u=>n.includes(u)),O=v.length===1,i=n.length>0?n.map(u=>`${u}: ${s[u]}`).join(", "):"",g=n.length>0?`let mut key_tuple = vector::empty();
-        ${n.map(u=>`key_tuple.push_back(to_bytes(&${u}));`).join(`
-        `)}`:"let key_tuple = vector::empty();",b=`    public fun get_table_id(): String {
-        string(TABLE_NAME)
     }
 
-    public fun get_key_schemas(): vector<String> { 
-        vector[${n.map(u=>`string(b"${s[u]}")`).join(", ")}]
+    public fun new(${S}): ${I(t)} {
+        ${I(t)} {
+${j}
+        }
     }
 
-    public fun get_value_schemas(): vector<String> { 
-        vector[${Object.values(o).map(u=>`string(b"${u}")`).join(", ")}]
-    }
+${M}
 
-    public fun get_key_names(): vector<String> { 
-        vector[${n.map(u=>`string(b"${u}")`).join(", ")}]
-    }
+${ee}
 
-    public fun get_value_names(): vector<String> { 
-        vector[${v.map(u=>`string(b"${u}")`).join(", ")}]
-    }`,f=`    public(package) fun register_table(dapp_hub: &mut DappHub, ctx: &mut TxContext) {
-        let dapp_key = dapp_key::new();
-        ${x(e)}::register_table(
-            dapp_hub,
-             dapp_key,
-            string(TABLE_TYPE),
-            get_table_id(), 
-            get_key_schemas(), 
-            get_key_names(), 
-            get_value_schemas(), 
-            get_value_names(), 
-            OFFCHAIN,
-            ctx
-        );
-    }`,m=`    public fun has(dapp_hub: &DappHub${i?", "+i:""}): bool {
-        ${g}
-        ${x(e)}::has_record<DappKey>(dapp_hub, get_table_id(), key_tuple)
+${x}
+}`}function B(e){return["address","bool","u8","u16","u32","u64","u128","u256","string","String","vector<address>","vector<bool>","vector<u8>","vector<u16>","vector<vector<u8>>","vector<u32>","vector<u64>","vector<u128>","vector<u256>","vector<String>"].includes(e)}function J(e,t,s,n){let r=!B(t),i=r?n.find(d=>d.type===t):null;return t==="string"||t==="String"?`dubhe::bcs::peel_string(&mut ${s})`:t==="vector<String>"?`dubhe::bcs::peel_vec_string(&mut ${s})`:r&&i?`${e}::${i.module}::decode(&mut ${s})`:`sui::bcs::peel_${ge(t)}(&mut ${s})`}function Ue(e,t,s,n,r,i,d){let l=`${n}_raw`,u=`${n}_bcs`;return[`let ${l} = ${t.get_field}<DappKey>(${s}, key_tuple, b"${n}");`,`let mut ${u} = sui::bcs::new(${l});`,`let ${n} = ${J(e,r,u,d)};`].join(`
+        `)}function it(e,t,s,n,r=!0,i=[],d="Onchain",l=!1,u="UserStorage",_="user_storage",g=le("dubhe",!1)){let y=Object.entries(s).filter(([c])=>!n.includes(c)).reduce((c,[f,S])=>({...c,[f]:S}),{}),o=Object.keys(y),b=Object.keys(s).every(c=>n.includes(c)),p=o.length===1,h=d==="Offchain",a=n.length>0?n.map(c=>`${c}: ${s[c]}`).join(", "):"",$=n.length>0?`let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        ${n.map(c=>`key_tuple.push_back(to_bytes(&${c}));`).join(`
+        `)}`:`let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);`,x=l?"":", ctx: &mut TxContext",k=l?"":", ctx",T=h?"":`    public fun has(${_}: &${u}${a?", ":""}${a}): bool {
+        ${$}
+        ${g.has_record}<DappKey>(${_}, key_tuple)
     }
 
-    public fun ensure_has(dapp_hub: &DappHub${i?", "+i:""}) {
-        ${g}
-        ${x(e)}::ensure_has_record<DappKey>(dapp_hub, get_table_id(), key_tuple)
+    public fun ensure_has(${_}: &${u}${a?", ":""}${a}) {
+        ${$}
+        ${g.ensure_has}<DappKey>(${_}, key_tuple)
     }
 
-    public fun ensure_not_has(dapp_hub: &DappHub${i?", "+i:""}) {
-        ${g}
-        ${x(e)}::ensure_not_has_record<DappKey>(dapp_hub, get_table_id(), key_tuple)
+    public fun ensure_has_not(${_}: &${u}${a?", ":""}${a}) {
+        ${$}
+        ${g.ensure_has_not}<DappKey>(${_}, key_tuple)
     }
-  `,p=`    public(package) fun delete(dapp_hub: &mut DappHub${i?", "+i:""}) {
-        ${g}
-        ${x(e)}::delete_record<DappKey>(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, OFFCHAIN);
-    }`,A=O?"":v.map(u=>{let y=v.indexOf(u),r=s[u],_=!T(r),d=_?l.find(F=>F.type===r):null;return`    public fun get_${u}(dapp_hub: &DappHub${i?", "+i:""}): ${r==="string"||r==="String"?"String":r} {
-        ${g}
-        let value = ${x(e)}::get_field<DappKey>(dapp_hub, get_table_id(), key_tuple, ${y});
-        let mut bsc_type = sui::bcs::new(value);
-        ${r==="string"||r==="String"?`let ${u} = dubhe::bcs::peel_string(&mut bsc_type);`:r==="vector<String>"?`let ${u} = dubhe::bcs::peel_vec_string(&mut bsc_type);`:_?`let ${u} = ${e}::${d?.module}::decode(&mut bsc_type);`:`let ${u} = sui::bcs::peel_${L(r)}(&mut bsc_type);`}
-        ${u}
+  `,w=`vector[${o.map(c=>`b"${c}"`).join(", ")}]`,F=h?"":`    public(package) fun delete(${_}: &mut ${u}${a?", ":""}${a}${l?"":", ctx: &TxContext"}) {
+        ${$}
+        ${g.delete_record}<DappKey>(${R(e)}${_}, key_tuple, ${w}${l?"":", ctx"});
+    }`,O=!p&&!h?o.map(c=>{let f=s[c],S=!B(f),j=S?i.find(M=>M.type===f):null;return`    public fun get_${c}(${_}: &${u}${a?", ":""}${a}): ${f==="string"||f==="String"?"String":f==="vector<String>"?"vector<String>":f} {
+        ${$}
+        let ${c}_raw = ${g.get_field}<DappKey>(${_}, key_tuple, b"${c}");
+        let mut ${c}_bcs = sui::bcs::new(${c}_raw);
+        let ${c} = ${J(e,f,`${c}_bcs`,i)};
+        ${c}
     }
 
-    public(package) fun set_${u}(dapp_hub: &mut DappHub${i?", "+i:""}, ${u}: ${r==="string"||r==="String"?"String":r}) {
-        ${g}
-        let value = ${r==="string"||r==="String"?`to_bytes(&into_bytes(${u}))`:r==="vector<String>"?`to_bytes(&${u})`:_?`${e}::${d?.module}::encode(${u})`:`to_bytes(&${u})`};
-        ${x(e)}::set_field(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, ${y}, value, OFFCHAIN);
+    public(package) fun set_${c}(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, ${c}: ${f==="string"||f==="String"?"String":f==="vector<String>"?"vector<String>":f}${x}) {
+        ${$}
+        let value = ${f==="string"||f==="String"?`to_bytes(&into_bytes(${c}))`:f==="vector<String>"?`to_bytes(&${c})`:S?`${e}::${j?.module}::encode(${c})`:`to_bytes(&${c})`};
+        ${g.set_field}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, b"${c}", value${k});
     }`}).join(`
 
-`),a=C?`    public(package) fun set(dapp_hub: &mut DappHub${i?", "+i:""}) {
-        ${g}
-        let value_tuple = vector::empty();
-        ${x(e)}::set_record(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, value_tuple, OFFCHAIN);
-    }`:O?`    public fun get(dapp_hub: &DappHub${i?", "+i:""}): ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]} {
-        ${g}
-        let value = ${x(e)}::get_field<DappKey>(dapp_hub, get_table_id(), key_tuple, 0);
-        let mut bsc_type = sui::bcs::new(value);
-        ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"let value = dubhe::bcs::peel_string(&mut bsc_type);":Object.values(o)[0]==="vector<String>"?"let value = dubhe::bcs::peel_vec_string(&mut bsc_type);":T(Object.values(o)[0])?`let value = sui::bcs::peel_${L(Object.values(o)[0])}(&mut bsc_type);`:`let value = ${e}::${l.find(u=>u.type===Object.values(o)[0])?.module}::decode(&mut bsc_type);`}
+`):"",A=`vector[${o.map(c=>`b"${c}"`).join(", ")}]`,D=b?`    public(package) fun set(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}${x}) {
+        ${$}
+        let field_names: vector<vector<u8>> = vector[];
+        let value_tuple: vector<vector<u8>> = vector[];
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`:p?h?`    public(package) fun set(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, value: ${Object.values(y)[0]==="string"||Object.values(y)[0]==="String"?"String":Object.values(y)[0]}${x}) {
+        ${$}
+        let field_names = vector[b"${o[0]}"];
+        let value_tuple = encode(value);
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`:`    public fun get(${_}: &${u}${a?", ":""}${a}): ${Object.values(y)[0]==="string"||Object.values(y)[0]==="String"?"String":Object.values(y)[0]} {
+        ${$}
+        let ${o[0]}_raw = ${g.get_field}<DappKey>(${_}, key_tuple, b"${o[0]}");
+        let mut ${o[0]}_bcs = sui::bcs::new(${o[0]}_raw);
+        let value = ${J(e,Object.values(y)[0],`${o[0]}_bcs`,i)};
         value
     }
 
-    public(package) fun set(dapp_hub: &mut DappHub${i?", "+i:""}, value: ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]}) {
-        ${g}
+    public(package) fun set(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, value: ${Object.values(y)[0]==="string"||Object.values(y)[0]==="String"?"String":Object.values(y)[0]}${x}) {
+        ${$}
+        let field_names = vector[b"${o[0]}"];
         let value_tuple = encode(value);
-        ${x(e)}::set_record(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, value_tuple, OFFCHAIN);
-    }`:`    public fun get(dapp_hub: &DappHub${i?", "+i:""}): (${Object.values(o).map(u=>u==="string"||u==="String"?"String":u).join(", ")}) {
-        ${g}
-        let value_tuple = ${x(e)}::get_record<DappKey>(dapp_hub, get_table_id(), key_tuple);
-        let mut bsc_type = sui::bcs::new(value_tuple);
-        ${v.map(u=>{let y=s[u],r=!T(y),_=r?l.find(d=>d.type===y):null;return`let ${u} = ${y==="string"||y==="String"?"dubhe::bcs::peel_string(&mut bsc_type)":y==="vector<String>"?"dubhe::bcs::peel_vec_string(&mut bsc_type)":r?`${e}::${_?.module}::decode(&mut bsc_type)`:`sui::bcs::peel_${L(y)}(&mut bsc_type)`};`}).join(`
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`:h?`    public(package) fun set(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, ${o.map(c=>`${c}: ${s[c]==="string"||s[c]==="String"?"String":s[c]}`).join(", ")}${x}) {
+        ${$}
+        let field_names = ${A};
+        let value_tuple = encode(${o.join(", ")});
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`:`    public fun get(${_}: &${u}${a?", ":""}${a}): (${Object.values(y).map(c=>c==="string"||c==="String"?"String":c).join(", ")}) {
+        ${$}
+        ${o.map((c,f)=>Ue(e,g,_,c,s[c],f,i)).join(`
         `)}
-        (${v.join(", ")})
+        (${o.join(", ")})
     }
 
-    public(package) fun set(dapp_hub: &mut DappHub${i?", "+i:""}, ${v.map(u=>`${u}: ${s[u]==="string"||s[u]==="String"?"String":s[u]}`).join(", ")}) {
-        ${g}
-        let value_tuple = encode(${v.join(", ")});
-        ${x(e)}::set_record(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, value_tuple, OFFCHAIN);
-    }`,w=c?`    public fun get_struct(dapp_hub: &DappHub${i?", "+i:""}): ${j(t)} {
-        ${g}
-        let value_tuple = ${x(e)}::get_record<DappKey>(dapp_hub, get_table_id(), key_tuple);
-        decode(value_tuple)
+    public(package) fun set(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, ${o.map(c=>`${c}: ${s[c]==="string"||s[c]==="String"?"String":s[c]}`).join(", ")}${x}) {
+        ${$}
+        let field_names = ${A};
+        let value_tuple = encode(${o.join(", ")});
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`,v=r?h?`    public(package) fun set_struct(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, ${t}: ${I(t)}${x}) {
+        ${$}
+        let field_names = ${A};
+        let value_tuple = encode_struct(${t});
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`:`    public fun get_struct(${_}: &${u}${a?", ":""}${a}): ${I(t)} {
+        ${$}
+        ${o.map((c,f)=>Ue(e,g,_,c,s[c],f,i)).join(`
+        `)}
+        ${I(t)} { ${o.join(", ")} }
     }
 
-    public(package) fun set_struct(dapp_hub: &mut DappHub${i?", "+i:""}, ${t}: ${j(t)}) {
-        ${g}
+    public(package) fun set_struct(${H(e,l)}${_}: &mut ${u}${a?", ":""}${a}, ${t}: ${I(t)}${x}) {
+        ${$}
+        let field_names = ${A};
         let value_tuple = encode_struct(${t});
-        ${x(e)}::set_record(dapp_hub, dapp_key::new(), get_table_id(), key_tuple, value_tuple, OFFCHAIN);
-    }`:"",B=O?`    public fun encode(value: ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]}): vector<vector<u8>> {
+        ${g.set_record}<DappKey>(${R(e)}${z(e,l)}${_}, key_tuple, field_names, value_tuple, OFFCHAIN${k});
+    }`:"",K=p?`    public fun encode(value: ${Object.values(y)[0]==="string"||Object.values(y)[0]==="String"?"String":Object.values(y)[0]}): vector<vector<u8>> {
         let mut value_tuple = vector::empty();
-        value_tuple.push_back(        ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"to_bytes(&into_bytes(value))":Object.values(o)[0]==="vector<String>"||T(Object.values(o)[0])?"to_bytes(&value)":`${e}::${l.find(u=>u.type===Object.values(o)[0])?.module}::encode(value)`});
+        value_tuple.push_back(${Object.values(y)[0]==="string"||Object.values(y)[0]==="String"?"to_bytes(&into_bytes(value))":Object.values(y)[0]==="vector<String>"||B(Object.values(y)[0])?"to_bytes(&value)":`${e}::${i.find(c=>c.type===Object.values(y)[0])?.module}::encode(value)`});
         value_tuple
-    }`:c?`    public fun encode(${v.map(u=>`${u}: ${s[u]==="string"||s[u]==="String"?"String":s[u]}`).join(", ")}): vector<vector<u8>> {
+    }`:r?h?`    public fun encode(${o.map(c=>`${c}: ${s[c]==="string"||s[c]==="String"?"String":s[c]}`).join(", ")}): vector<vector<u8>> {
         let mut value_tuple = vector::empty();
-        ${v.map(u=>{let y=s[u],r=!T(y),_=r?l.find(d=>d.type===y):null;return`value_tuple.push_back(${y==="string"||y==="String"?`to_bytes(&into_bytes(${u}))`:y==="vector<String>"?`to_bytes(&${u})`:r?`${e}::${_?.module}::encode(${u})`:`to_bytes(&${u})`});`}).join(`
+        ${o.map(c=>{let f=s[c],S=!B(f),j=S?i.find(M=>M.type===f):null;return`value_tuple.push_back(${f==="string"||f==="String"?`to_bytes(&into_bytes(${c}))`:f==="vector<String>"?`to_bytes(&${c})`:S?`${e}::${j?.module}::encode(${c})`:`to_bytes(&${c})`});`}).join(`
         `)}
         value_tuple
     }
 
-    public fun encode_struct(${t}: ${j(t)}): vector<vector<u8>> {
-        encode(${v.map(u=>`${t}.${u}`).join(", ")})
+    public fun encode_struct(${t}: ${I(t)}): vector<vector<u8>> {
+        encode(${o.map(c=>`${t}.${c}`).join(", ")})
+    }`:`    public fun encode(${o.map(c=>`${c}: ${s[c]==="string"||s[c]==="String"?"String":s[c]}`).join(", ")}): vector<vector<u8>> {
+        let mut value_tuple = vector::empty();
+        ${o.map(c=>{let f=s[c],S=!B(f),j=S?i.find(M=>M.type===f):null;return`value_tuple.push_back(${f==="string"||f==="String"?`to_bytes(&into_bytes(${c}))`:f==="vector<String>"?`to_bytes(&${c})`:S?`${e}::${j?.module}::encode(${c})`:`to_bytes(&${c})`});`}).join(`
+        `)}
+        value_tuple
     }
 
-    public fun decode(data: vector<u8>): ${j(t)} {
-        let mut bsc_type = sui::bcs::new(data);
-        ${v.map(u=>{let y=s[u],r=!T(y),_=r?l.find(d=>d.type===y):null;return`let ${u} = ${y==="string"||y==="String"?"string(sui::bcs::peel_vec_u8(&mut bsc_type))":y==="vector<String>"?"dubhe::bcs::peel_vec_string(&mut bsc_type)":r?`${e}::${_?.module}::decode(&mut bsc_type)`:`sui::bcs::peel_${L(y)}(&mut bsc_type)`};`}).join(`
+    public fun encode_struct(${t}: ${I(t)}): vector<vector<u8>> {
+        encode(${o.map(c=>`${t}.${c}`).join(", ")})
+    }
+
+    public fun decode(data: vector<u8>): ${I(t)} {
+        let mut bcs_type = sui::bcs::new(data);
+        ${o.map(c=>{let f=s[c],S=!B(f),j=S?i.find(M=>M.type===f):null;return`let ${c} = ${f==="string"||f==="String"?"string(sui::bcs::peel_vec_u8(&mut bcs_type))":f==="vector<String>"?"dubhe::bcs::peel_vec_string(&mut bcs_type)":S?`${e}::${j?.module}::decode(&mut bcs_type)`:`sui::bcs::peel_${ge(f)}(&mut bcs_type)`};`}).join(`
         `)}
-        ${j(t)} {
-            ${v.map(u=>`${u},`).join(`
+        ${I(t)} {
+            ${o.map(c=>`${c},`).join(`
             `)}
         }
-    }`:"";return`${b}
+    }`:"";return[T,F,O,D,v,K].filter(c=>c.trim().length>0).join(`
 
-${f}
+`)}function I(e){return e.split("_").map((t,s)=>/^\d+$/.test(t)?t:t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}function ge(e){if(e.startsWith("vector<")){let t=e.slice(7,-1);return t==="vector<u8>"?"vec_vec_u8":t==="String"?"vec_string":`vec_${ge(t)}`}switch(e){case"u8":return"u8";case"u16":return"u16";case"u32":return"u32";case"u64":return"u64";case"u128":return"u128";case"u256":return"u256";case"bool":return"bool";case"address":return"address";case"String":return"string";default:return e}}function at(e,t,s){let n=[],r=e.name,i=Me(r),d=R(r),l=s.fields,u=s.keys??[],_=Object.entries(l).filter(([o])=>!u.includes(o)),g=_.map(([o])=>o),y=u.length>0?u.map(o=>`${o}: ${l[o]}`).join(", "):"";if(s.fungible&&g.length===1){let[o,b]=_[0];n.push(`
+    // \u2500\u2500\u2500 fungible add / sub \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    #[error]
+    const EInsufficientAmount: vector<u8> = b"Insufficient amount";
 
-${m}
+    public(package) fun add(user_storage: &mut UserStorage, amount: ${b}, ctx: &mut TxContext) {
+        let current = if (has(user_storage)) { get(user_storage) } else { 0 };
+        set(user_storage, current + amount, ctx);
+    }
 
-${p}
+    public(package) fun sub(user_storage: &mut UserStorage, amount: ${b}, ctx: &mut TxContext) {
+        let current = get(user_storage);
+        assert!(current >= amount, EInsufficientAmount);
+        set(user_storage, current - amount, ctx);
+    }`)}if(u.length>0&&!s.offchain&&!s.global){let o=u.map($=>`${$}: ${l[$]}`).join(", "),b=g.map($=>`${$}: ${l[$]}`).join(", "),p=[o,b].filter(Boolean).join(", "),h=u.join(", "),a=[...u,...g].join(", ");n.push(`
+    // \u2500\u2500\u2500 keys: mint (developer provides keys; framework ensures no duplicate) \u2500
+    // Choosing the ID strategy (fresh address, counter, coordinate pack, etc.)
+    // is intentionally left to the caller.
+    public(package) fun mint(
+        user_storage: &mut UserStorage,
+        ${p},
+        ctx: &mut TxContext,
+    ) {
+        ensure_has_not(user_storage, ${h});
+        set(user_storage, ${a}, ctx);
+    }`)}if(s.reactive){let o=u.length>0?`let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);
+        ${u.map(b=>`key_tuple.push_back(sui::bcs::to_bytes(&${b}));`).join(`
+        `)}`:`let mut key_tuple = vector::empty();
+        key_tuple.push_back(TABLE_NAME);`;if(g.length>1){let b=g.map(p=>`${p}: ${l[p]}`).join(", ");n.push(`
+    // \u2500\u2500\u2500 reactive: cross-user write variants \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    // Package-level helpers: add pause checks and access control in your system
+    // functions before calling these.
+    public(package) fun set_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        ${y?y+", ":""}${b},
+        ctx:    &mut TxContext,
+    ) {
+        ${o}
+        let field_names = vector[${g.map(p=>`b"${p}"`).join(", ")}];
+        let value_tuple = encode(${g.join(", ")});
+        ${i}::set_record_reactive<DappKey, PermType>(${d}permit, from, target, key_tuple, field_names, value_tuple, ctx);
+    }`)}for(let[b,p]of _){let h=p==="string"||p==="String"?`sui::bcs::to_bytes(&std::ascii::into_bytes(${b}))`:`sui::bcs::to_bytes(&${b})`;n.push(`
+    public(package) fun set_${b}_reactive<PermType>(
+        permit: &ScenePermit<PermType>,
+        from:   &mut UserStorage,
+        target: &mut UserStorage,
+        ${y?y+", ":""}${b}: ${p==="string"||p==="String"?"String":p},
+        ctx:    &mut TxContext,
+    ) {
+        ${o}
+        let value = ${h};
+        ${i}::set_field_reactive<DappKey, PermType>(${d}permit, from, target, key_tuple, b"${b}", value, ctx);
+    }`)}}if(s.transferable){let o=e.objects??{},b=e.scenes??{},p=!!s.fungible,h=!p&&u.length>0,a=h?u[0]:null;for(let[$,x]of Object.entries(o)){if(!(x.accepts??[]).includes(t))continue;let k=I($),T=`dubhe::dapp_service::ObjectStorage<${r}::${$}::${k}>`,w=$;if(p&&g.length===1){let[,F]=_[0];n.push(`
+    // \u2500\u2500\u2500 transferable: User \u2194 ${k}Storage (fungible) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    public(package) fun transfer_user_to_${$}(
+        user:   &mut UserStorage,
+        target: &mut ${T},
+        amount: ${F},
+        ctx:    &mut TxContext,
+    ) {
+        sub(user, amount, ctx);
+        ${r}::${w}::add_${t}(target, amount);
+    }
 
-${A}
+    public(package) fun transfer_${$}_to_user(
+        source: &mut ${T},
+        user:   &mut UserStorage,
+        amount: ${F},
+        ctx:    &mut TxContext,
+    ) {
+        ${r}::${w}::sub_${t}(source, amount);
+        add(user, amount, ctx);
+    }`)}else if(h&&a)if(g.length===1){let[,F]=_[0],O=F==="string"||F==="String"?`to_bytes(&std::ascii::into_bytes(get(user, ${a})))`:`to_bytes(&get(user, ${a}))`,A=Object.entries(e.enums??{}).map(([v])=>({type:I(v),module:v})),D=J(r,F,"bcs",A);n.push(`
+    // \u2500\u2500\u2500 transferable: User \u2194 ${k}Storage (keyed) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    public(package) fun transfer_user_to_${$}(
+        user:     &mut UserStorage,
+        target:   &mut ${T},
+        ${a}: u64,
+        ctx:      &TxContext,
+    ) {
+        ensure_has(user, ${a});
+        // Guard before any mutation: abort if target already holds this item.
+        dubhe::error::item_already_owned(!${r}::${w}::has_${t}(target, ${a}));
+        let raw = ${O};
+        delete(user, ${a}, ctx);
+        ${r}::${w}::set_${t}_data(target, ${a}, raw);
+    }
 
-${a}
+    public(package) fun transfer_${$}_to_user(
+        source:   &mut ${T},
+        user:     &mut UserStorage,
+        ${a}: u64,
+        ctx:      &mut TxContext,
+    ) {
+        // Guard before any mutation: abort if user already owns this item.
+        ensure_has_not(user, ${a});
+        let raw = ${r}::${w}::remove_${t}_data(source, ${a});
+        let mut bcs = sui::bcs::new(raw);
+        let value = ${D};
+        set(user, ${a}, value, ctx);
+    }`)}else n.push(`
+    // \u2500\u2500\u2500 transferable: User \u2194 ${k}Storage (keyed, multi-field) \u2500\u2500
+    public(package) fun transfer_user_to_${$}(
+        user:     &mut UserStorage,
+        target:   &mut ${T},
+        ${a}: u64,
+        ctx:      &TxContext,
+    ) {
+        ensure_has(user, ${a});
+        // Guard before any mutation: abort if target already holds this item.
+        dubhe::error::item_already_owned(!${r}::${w}::has_${t}(target, ${a}));
+        let data = encode_struct(get_struct(user, ${a}));
+        delete(user, ${a}, ctx);
+        let raw: vector<u8> = sui::bcs::to_bytes(&data);
+        ${r}::${w}::set_${t}_data(target, ${a}, raw);
+    }
 
-${w}
+    public(package) fun transfer_${$}_to_user(
+        source:   &mut ${T},
+        user:     &mut UserStorage,
+        ${a}: u64,
+        ctx:      &mut TxContext,
+    ) {
+        // Guard before any mutation: abort if user already owns this item.
+        ensure_has_not(user, ${a});
+        let raw = ${r}::${w}::remove_${t}_data(source, ${a});
+        let decoded = decode(raw);
+        set_struct(user, ${a}, decoded, ctx);
+    }`)}for(let[$,x]of Object.entries(b)){if(!(x.accepts??[]).includes(t))continue;let k=I($),T=`dubhe::dapp_service::SceneStorage<${r}::${$}::${k}>`,w=$,F=x.authorization.kind==="permit"?`dubhe::dapp_service::ScenePermit<${r}::${x.authorization.permit}::${I(x.authorization.permit)}>`:"",O=x.authorization.kind==="permit"?`        permit: &${F},
+`:"",A=x.authorization.kind==="permit"?"permit, ":"",D=x.authorization.kind==="permit"?"user, ":"",v=x.authorization.kind==="permit"?", ctx":"";if(p&&g.length===1){let[,K]=_[0];n.push(`
+    // \u2500\u2500\u2500 transferable: User \u2194 ${k}Storage (fungible) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    public(package) fun transfer_user_to_${$}(
+${O}        user:   &mut UserStorage,
+        target: &mut ${T},
+        amount: ${K},
+        ctx:    &mut TxContext,
+    ) {
+        sub(user, amount, ctx);
+        ${r}::${w}::add_${t}(${A}target, ${D}amount${v});
+    }
 
-${B}`}function j(e){return e.split("_").map((t,s)=>/^\d+$/.test(t)?t:t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}function L(e){if(e.startsWith("vector<")){let t=e.slice(7,-1);return t==="vector<u8>"?"vec_vec_u8":t==="String"?"vec_string":`vec_${L(t)}`}switch(e){case"u8":return"u8";case"u16":return"u16";case"u32":return"u32";case"u64":return"u64";case"u128":return"u128";case"u256":return"u256";case"bool":return"bool";case"address":return"address";case"String":return"string";default:return e}}async function ge(e,t){let s=`module ${e.name}::genesis {
-      use sui::clock::Clock;
-      use dubhe::dapp_service::DappHub;
-      use ${e.name}::dapp_key;
-      use dubhe::dapp_system;
-      use std::ascii::string;
+    // \u2605 No expiry check on withdraw direction \u2014 prevents asset lock-in expired scenes.
+    public(package) fun transfer_${$}_to_user(
+${O}        source: &mut ${T},
+        user:   &mut UserStorage,
+        amount: ${K},
+        ctx:    &mut TxContext,
+    ) {
+        ${r}::${w}::sub_${t}(${A}source, ${D}amount${v});
+        add(user, amount, ctx);
+    }`)}else if(h&&a)if(g.length===1){let[,K]=_[0],P=K==="string"||K==="String"?`to_bytes(&std::ascii::into_bytes(get(user, ${a})))`:`to_bytes(&get(user, ${a}))`,c=Object.entries(e.enums??{}).map(([S])=>({type:I(S),module:S})),f=J(r,K,"bcs",c);n.push(`
+    // \u2500\u2500\u2500 transferable: User \u2194 ${k}Storage (keyed) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    public(package) fun transfer_user_to_${$}(
+${O}        user:   &mut UserStorage,
+        target: &mut ${T},
+        ${a}: u64,
+        ctx:    &TxContext,
+    ) {
+        ensure_has(user, ${a});
+        // Guard before any mutation: abort if target already holds this item.
+        dubhe::error::item_already_owned(!${r}::${w}::has_${t}(target, ${a}));
+        let raw = ${P};
+        delete(user, ${a}, ctx);
+        ${r}::${w}::set_${t}_data(${A}target, ${D}${a}, raw${v});
+    }
 
-  public entry fun run(dapp_hub: &mut DappHub, clock: &Clock, ctx: &mut TxContext) {
-    // Create Dapp
-    let dapp_key = dapp_key::new();
-    dapp_system::create_dapp(dapp_hub, dapp_key, string(b"${e.name}"), string(b"${e.description}"), clock, ctx);
+    public(package) fun transfer_${$}_to_user(
+${O}        source: &mut ${T},
+        user:   &mut UserStorage,
+        ${a}: u64,
+        ctx:    &mut TxContext,
+    ) {
+        // Guard before any mutation: abort if user already owns this item.
+        ensure_has_not(user, ${a});
+        let raw = ${r}::${w}::remove_${t}_data(${A}source, ${D}${a}${v});
+        let mut bcs = sui::bcs::new(raw);
+        let value = ${f};
+        set(user, ${a}, value, ctx);
+    }`)}else n.push(`
+    // \u2500\u2500\u2500 transferable: User \u2194 ${k}Storage (keyed, multi-field) \u2500
+    public(package) fun transfer_user_to_${$}(
+${O}        user:   &mut UserStorage,
+        target: &mut ${T},
+        ${a}: u64,
+        ctx:    &TxContext,
+    ) {
+        ensure_has(user, ${a});
+        // Guard before any mutation: abort if target already holds this item.
+        dubhe::error::item_already_owned(!${r}::${w}::has_${t}(target, ${a}));
+        let data = encode_struct(get_struct(user, ${a}));
+        delete(user, ${a}, ctx);
+        let raw: vector<u8> = sui::bcs::to_bytes(&data);
+        ${r}::${w}::set_${t}_data(${A}target, ${D}${a}, raw${v});
+    }
 
-    // Logic that needs to be automated once the contract is deployed
-    ${e.name}::deploy_hook::run(dapp_hub, ctx);
-  }
-}
-`;await h(s,t,"formatAndWriteMove")}function $e(e){return e.replace(/[A-Z]/g,t=>`_${t.toLowerCase()}`).replace(/^_/,"")}async function ye(e,t){if(console.log(`
-\u{1F4E6} Starting Enums Generation...`),!!e.enums)for(let[s,n]of Object.entries(e.enums)){console.log(`     \u2514\u2500 ${s}: ${JSON.stringify(n)}`);let c=[...n].sort((S,D)=>S.localeCompare(D)),l=Ae(e.name,s,c);await h(l,`${t}/${$e(s)}.move`,"formatAndWriteMove")}}function Ae(e,t,s){let n=s.map(c=>c.charAt(0).toUpperCase()+c.slice(1)).join(",");return`module ${e}::${$e(t)} {
-    use sui::bcs::{BCS, to_bytes, peel_enum_tag};
+    public(package) fun transfer_${$}_to_user(
+${O}        source: &mut ${T},
+        user:   &mut UserStorage,
+        ${a}: u64,
+        ctx:    &mut TxContext,
+    ) {
+        // Guard before any mutation: abort if user already owns this item.
+        ensure_has_not(user, ${a});
+        let raw = ${r}::${w}::remove_${t}_data(${A}source, ${D}${a}${v});
+        let decoded = decode(raw);
+        set_struct(user, ${a}, decoded, ctx);
+    }`)}}if(s.listable){let o=!!s.fungible,p=!o&&u.length>0,h=p?u[0]:null,a=`b"${t}"`;if(o&&g.length===1)n.push(`
+    // \u2500\u2500\u2500 listable: market protocol (fungible) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    // Package-level helpers: call these from your system functions.
+    // Add pause checks, access control, and custom logic there.
+    public(package) fun list<CoinType>(
+        user_storage: &mut UserStorage,
+        amount:       u64,
+        price:        u64,
+        listed_until: std::option::Option<u64>,
+        ctx:          &mut TxContext,
+    ) {
+        dubhe::dapp_system::take_fungible_record<DappKey, CoinType>(
+            dapp_key::new(),
+            user_storage,
+            ${a},
+            { let mut k = vector::empty(); k.push_back(TABLE_NAME); k },
+            b"${g[0]}",
+            amount,
+            price,
+            listed_until,
+            ctx,
+        );
+    }
 
-    public enum ${t} has copy, drop, store {
-        ${n}
+    public(package) fun buy<CoinType>(
+        dh:            &dubhe::dapp_service::DappHub,
+        dapp_storage:  &mut DappStorage,
+        listing:       dubhe::dapp_service::Listing<CoinType>,
+        user_storage:  &mut UserStorage,
+        payment:       sui::coin::Coin<CoinType>,
+        ctx:           &mut TxContext,
+    ): sui::coin::Coin<CoinType> {
+        dubhe::dapp_system::buy_fungible_record<DappKey, CoinType>(
+            dapp_key::new(), dh, dapp_storage, listing, user_storage, payment, ctx
+        )
     }
 
-${s.map(c=>`    public fun new_${c.toLowerCase()}(): ${t} {
-        ${t}::${c.charAt(0).toUpperCase()+c.slice(1)}
-    }`).join(`
+    public(package) fun cancel_listing<CoinType>(
+        listing:      dubhe::dapp_service::Listing<CoinType>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::cancel_fungible_listing<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
+    }
 
-`)}
+    public(package) fun expire_listing<CoinType>(
+        listing:      dubhe::dapp_service::Listing<CoinType>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::expire_fungible_listing<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
+    }`);else if(p&&h){let $=u.map(k=>`${k}:   ${l[k]}`).join(`,
+        `),x=u.map(k=>`record_key.push_back(sui::bcs::to_bytes(&${k}));`).join(`
+        `);n.push(`
+    // \u2500\u2500\u2500 listable: market protocol (keyed) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    // Package-level helpers: call these from your system functions.
+    // Add pause checks, access control, and custom logic there.
+    public(package) fun list<CoinType>(
+        user_storage: &mut UserStorage,
+        ${$},
+        price:        u64,
+        listed_until: std::option::Option<u64>,
+        ctx:          &mut TxContext,
+    ) {
+        let mut record_key = vector::empty();
+        record_key.push_back(TABLE_NAME);
+        ${x}
+        dubhe::dapp_system::take_record<DappKey, CoinType>(
+            dapp_key::new(),
+            user_storage,
+            ${a},
+            record_key,
+            vector[${g.map(k=>`b"${k}"`).join(", ")}],
+            price,
+            listed_until,
+            ctx,
+        );
+    }
 
-    public fun encode(self: ${t}): vector<u8> {
-        to_bytes(&self)
+    public(package) fun buy<CoinType>(
+        dh:            &dubhe::dapp_service::DappHub,
+        dapp_storage:  &mut DappStorage,
+        listing:       dubhe::dapp_service::Listing<CoinType>,
+        user_storage:  &mut UserStorage,
+        payment:       sui::coin::Coin<CoinType>,
+        ctx:           &mut TxContext,
+    ): sui::coin::Coin<CoinType> {
+        dubhe::dapp_system::buy_record<DappKey, CoinType>(
+            dapp_key::new(), dh, dapp_storage, listing, user_storage, payment, ctx
+        )
     }
 
-    public fun decode(bytes: &mut BCS): ${t} {
-        match(peel_enum_tag(bytes)) {
-${s.map((c,l)=>`            ${l} => ${t}::${c.charAt(0).toUpperCase()+c.slice(1)},`).join(`
-`)}
-            _ => abort,
-        }
+    public(package) fun cancel_listing<CoinType>(
+        listing:      dubhe::dapp_service::Listing<CoinType>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::restore_record<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
     }
-}`}function k(e){return e==="dubhe"?"dapp_service":"dapp_system"}async function q(e,t){console.log(`
-\u{1F4E6} Starting Resources Generation...`);for(let[s,n]of Object.entries(e.resources)){if(console.log(`     \u2514\u2500 ${s}: ${JSON.stringify(n)}`),typeof n=="string"){let l=we(e.name,s,n,"Onchain");await h(l,`${t}/${s}.move`,"formatAndWriteMove");continue}if(!n.fields||Object.keys(n.fields).length===0)throw new Error(`Resource '${s}' must have fields defined, but found empty object`);n.keys||(n.keys=[]);let c=Fe(e.name,s,n);await h(c,`${t}/${s}.move`,"formatAndWriteMove")}}function we(e,t,s,n="Onchain"){let c=!M(s),l=c?`${ve(s)}`:"",D=n==="Offchain"?"":`
-    public fun has(dapp_hub: &DappHub, resource_account: String): bool {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        ${k(e)}::has_record<DappKey>(dapp_hub, resource_account, key_tuple)
+
+    public(package) fun expire_listing<CoinType>(
+        listing:      dubhe::dapp_service::Listing<CoinType>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::expire_listing<DappKey, CoinType>(
+            dapp_key::new(), listing, user_storage, ctx
+        );
+    }`)}}return n.join(`
+`)}import ct from"node:path";function V(e){return e.split("_").map(t=>/^\d+$/.test(t)?t:t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}function ut(e){return e==="string"||e==="String"?"String":e}function te(e){return`dubhe::dapp_service::ObjectStorage<${e}>`}function pt(e,t){let s=V(e),n=te(s),r=[];for(let[i,d]of Object.entries(t.fields)){let l=ut(d);r.push(`
+    public fun get_${i}(storage: &${n}): ${l} {
+        dubhe::dapp_system::get_object_field<${s}, ${l}>(storage, b"${i}")
     }
 
-    public(package) fun delete(dapp_hub: &mut DappHub, resource_account: String) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        ${k(e)}::delete_record<DappKey>(dapp_hub, dapp_key::new(), key_tuple, resource_account);
+    public(package) fun set_${i}(storage: &mut ${n}, value: ${l}) {
+        dubhe::dapp_system::set_object_field<DappKey, ${s}, ${l}>(
+            dapp_key::new(), storage, b"${i}", value
+        );
+    }`)}return r.join(`
+`)}function dt(e,t){let s=V(e),n=te(s);return`
+    public fun get_${t}(storage: &${n}): u64 {
+        if (dubhe::dapp_system::has_object_field<${s}, u64>(storage, b"${t}")) {
+            dubhe::dapp_system::get_object_field<${s}, u64>(storage, b"${t}")
+        } else { 0 }
     }
 
-    public fun get(dapp_hub: &DappHub, resource_account: String): (${s==="string"||s==="String"?"String":s}) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value_tuple = ${k(e)}::get_record<DappKey>(dapp_hub, resource_account, key_tuple);
-        let mut bsc_type = sui::bcs::new(value_tuple);
-        ${s==="string"||s==="String"?"let value = dubhe::bcs::peel_string(&mut bsc_type);":s==="vector<String>"?"let value = dubhe::bcs::peel_vec_string(&mut bsc_type);":c?`let value = ${e}::${l}::decode(&mut bsc_type);`:`let value = sui::bcs::peel_${W(s)}(&mut bsc_type);`}
-        (value)
+    public(package) fun add_${t}(storage: &mut ${n}, amount: u64) {
+        let current = get_${t}(storage);
+        dubhe::dapp_system::set_object_field<DappKey, ${s}, u64>(
+            dapp_key::new(), storage, b"${t}", current + amount
+        );
     }
-`;return`module ${e}::${t} { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
-    use dubhe::dapp_system;
-    use ${e}::dapp_key;
-    use ${e}::dapp_key::DappKey;
-${c&&s!=="string"&&s!=="String"?`    use ${e}::${l};
-    use ${e}::${l}::{${s}};`:""}
 
-    const TABLE_NAME: vector<u8> = b"${t}";
-    const OFFCHAIN: bool = ${n==="Offchain"};
+    public(package) fun sub_${t}(storage: &mut ${n}, amount: u64) {
+        let current = get_${t}(storage);
+        assert!(current >= amount, EInsufficientAmount);
+        dubhe::dapp_system::set_object_field<DappKey, ${s}, u64>(
+            dapp_key::new(), storage, b"${t}", current - amount
+        );
+    }`}function lt(e,t,s){let n=V(e),r=te(n);return`
+    public fun has_${t}(storage: &${r}, ${s}: u64): bool {
+        let key = sui::bcs::to_bytes(&${s});
+        dubhe::dapp_system::has_object_field<${n}, vector<u8>>(storage, key)
+    }
 
-${D}
-    public(package) fun set(dapp_hub: &mut DappHub, resource_account: String, value: ${s==="string"||s==="String"?"String":s}, ctx: &mut TxContext) {
-        let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        let value_tuple = encode(value);
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, resource_account, OFFCHAIN, ctx);
+    public fun get_${t}_data(storage: &${r}, ${s}: u64): vector<u8> {
+        let key = sui::bcs::to_bytes(&${s});
+        dubhe::dapp_system::get_object_field<${n}, vector<u8>>(storage, key)
     }
 
-    public fun encode(value: ${s==="string"||s==="String"?"String":s}): vector<vector<u8>> {
-        let mut value_tuple = vector::empty();
-        value_tuple.push_back(${s==="string"||s==="String"?"to_bytes(&into_bytes(value))":s==="vector<String>"?"to_bytes(&value)":c?`${e}::${l}::encode(value)`:"to_bytes(&value)"});
-        value_tuple
+    public(package) fun set_${t}_data(storage: &mut ${r}, ${s}: u64, data: vector<u8>) {
+        let key = sui::bcs::to_bytes(&${s});
+        assert!(!dubhe::dapp_system::has_object_field<${n}, vector<u8>>(storage, key), EDuplicateItemId);
+        dubhe::dapp_system::set_object_field<DappKey, ${n}, vector<u8>>(
+            dapp_key::new(), storage, key, data
+        );
     }
-}`}function ve(e){return e.replace(/[A-Z]/g,t=>`_${t.toLowerCase()}`).replace(/^_/,"")}function Fe(e,t,s){let n=s.fields,c=s.keys||[],l=s.offchain||!1,S=s.global||!1,D=l?"Offchain":"Onchain",o=l||S,$=Object.keys(n).every(a=>c.includes(a)),v=Object.entries(n).filter(([a])=>!c.includes(a)),C=v.map(([a])=>a),O=C.length===1,i=v.filter(([a,w])=>!M(w)&&w!=="string"&&w!=="String").map(([a,w])=>({type:w,module:`${ve(w)}`})).filter((a,w,B)=>B.findIndex(u=>u.type===a.type)===w),g=He(e,t,n,c,!$&&!O,i,D,o);if($||O)return`module ${e}::${t} { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
-    use dubhe::dapp_system;
-    use ${e}::dapp_key;
-    use ${e}::dapp_key::DappKey;
-${i.length>0?i.map(a=>`    use ${e}::${a.module};
-    use ${e}::${a.module}::{${a.type}};`).join(`
-`):""}
 
-    const TABLE_NAME: vector<u8> = b"${t}";
-    const OFFCHAIN: bool = ${l};
+    public(package) fun remove_${t}_data(storage: &mut ${r}, ${s}: u64): vector<u8> {
+        let key = sui::bcs::to_bytes(&${s});
+        assert!(dubhe::dapp_system::has_object_field<${n}, vector<u8>>(storage, key), EFieldNotFound);
+        dubhe::dapp_system::remove_object_field<DappKey, ${n}, vector<u8>>(dapp_key::new(), storage, key)
+    }`}function gt(e,t,s,n,r){let i=r.resources??{},d=r.objects??{},l=r.scenes??{},u=V(t),_=te(u),g=[],y=[];for(let o of n){let b=d[o]??l[o];if(!b)continue;let p=b.accepts??[],h=V(o);g.push(`    use ${e}::${o};`);let a=p.filter($=>s.includes($));for(let $ of a){let x=i[$];if(!x||typeof x=="string")continue;let k=x,T=!!l[o],w=`${e}::${o}::${h}`,F=T?`dubhe::dapp_service::SceneStorage<${w}>`:`dubhe::dapp_service::ObjectStorage<${w}>`,O=T?l[o]:void 0,A=O?.authorization.kind==="permit"?`dubhe::dapp_service::ScenePermit<${e}::${O.authorization.permit}::${V(O.authorization.permit)}>`:"",D=O?.authorization.kind==="permit"?`        source_permit: &${A},
+`:"",v=O?.authorization.kind==="permit",K=v?"source_permit, ":"",P=v?`        user_storage: &dubhe::dapp_service::UserStorage,
+`:"",c=v?"user_storage, ":"",f=v?`        ctx:        &TxContext,
+`:"",S=v?", ctx":"";if(!k.fungible&&k.keys?.length){let j=k.keys[0];y.push(`
+    /// Transfer ${$} (keyed item) from ${o} into this ${t}.
+    public(package) fun transfer_${o}_to_${t}_${$}(
+${D}        from:       &mut ${F},
+        to:         &mut ${_},
+${P}        ${j}: u64,
+${f}
+    ) {
+        let data = ${o}::remove_${$}_data(${K}from, ${c}${j}${S});
+        set_${$}_data(to, ${j}, data);
+    }`)}else y.push(`
+    /// Transfer ${$} (fungible) from ${o} into this ${t}.
+    public(package) fun transfer_${o}_to_${t}_${$}(
+${D}        from:   &mut ${F},
+        to:     &mut ${_},
+${P}        amount: u64,
+${f}
+    ) {
+        ${o}::sub_${$}(${K}from, ${c}amount${S});
+        add_${$}(to, amount);
+    }`)}}return{imports:g,functions:y}}async function Be(e,t){if(!e.objects||Object.keys(e.objects).length===0)return;console.log(`
+\u{1F4E6} Starting Object Storage Generation...`);let s=e.name,n=e.resources??{};for(let[r,i]of Object.entries(e.objects)){console.log(`     \u2514\u2500 ${r}`);let d=V(r),l=`${d}Storage`,u=`b"${r}"`,_=pt(r,i),g=i.accepts??[],y=[];for(let S of g){let j=n[S];if(!j||typeof j=="string")continue;let M=j;!M.fungible&&M.keys?.length?y.push(lt(r,S,M.keys[0])):y.push(dt(r,S))}let{imports:o,functions:b}=gt(s,r,g,i.acceptsFrom??[],e),p=i.adminOnly?"        assert!(ctx.sender() == dubhe::dapp_service::dapp_admin(dapp_storage), ENoPermission);":"",h=`dubhe::dapp_service::ObjectStorage<${d}>`,a=`
+    public fun assert_${r}_id(storage: &${h}, expected: vector<u8>) {
+        assert!(*dubhe::dapp_service::object_storage_entity_id(storage) == expected, EWrongEntityId);
+    }`,$=`
+    public fun entity_id(storage: &${h}): vector<u8> {
+        *dubhe::dapp_service::object_storage_entity_id(storage)
+    }`,T=Object.values(i.fields).some(S=>S==="string"||S==="String"||S==="vector<String>")?`
+    use std::ascii::String;`:"",w=g.some(S=>{let j=n[S];return!j||typeof j=="string"?!1:!!j.keys?.length&&!j.fungible}),F=g.some(S=>{let j=n[S];return!j||typeof j=="string"?!1:!!j.fungible}),O=w,A=F,D=w,v=!!i.adminOnly,K=[O?`    #[error]
+    const EFieldNotFound: vector<u8> = b"Field not found";`:"",A?`    #[error]
+    const EInsufficientAmount: vector<u8> = b"Insufficient amount";`:"",D?`    #[error]
+    const EDuplicateItemId: vector<u8> = b"Duplicate item id";`:"",`    #[error]
+    const EWrongEntityId: vector<u8> = b"Wrong entity id";`,v?`    #[error]
+    const ENoPermission: vector<u8> = b"Caller does not have permission";`:""].filter(Boolean).join(`
+`),P=o.length>0?`
+`+o.join(`
+`):"",c=`dubhe::dapp_service::ObjectStorage<${d}>`,f=`module ${s}::${r} {
+    use dubhe::dapp_service::DappStorage;
+    use ${s}::dapp_key;
+    use ${s}::dapp_key::DappKey;${T}${P}
+
+    // \u2500\u2500\u2500 Error constants \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${K}
+
+    const TYPE_TAG: vector<u8> = ${u};
+
+    // \u2500\u2500\u2500 Phantom marker type \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    /// Phantom type that distinguishes ${l} from other ObjectStorage types
+    /// at the Move compiler level, preserving compile-time type safety.
+    /// All functions use ObjectStorage<${d}> directly in their signatures.
+    public struct ${d} has copy, drop {}
+
+    // \u2500\u2500\u2500 ID / entity accessors \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${$}
 
-${g}
-}`;let b=C.map(a=>`        ${a}: ${n[a]==="string"||n[a]==="String"?"String":n[a]==="vector<String>"?"vector<String>":n[a]},`).join(`
-`),f=C.map(a=>`${a}: ${n[a]==="string"||n[a]==="String"?"String":n[a]==="vector<String>"?"vector<String>":n[a]}`).join(", "),m=C.map(a=>`            ${a},`).join(`
-`),p=C.map(a=>`    public fun ${a}(self: &${H(t)}): ${n[a]==="string"||n[a]==="String"?"String":n[a]==="vector<String>"?"vector<String>":n[a]} {
-        self.${a}
-    }`).join(`
+${a}
 
-`),A=C.map(a=>`    public fun update_${a}(self: &mut ${H(t)}, ${a}: ${n[a]==="string"||n[a]==="String"?"String":n[a]==="vector<String>"?"vector<String>":n[a]}) {
-        self.${a} = ${a}
-    }`).join(`
+    // \u2500\u2500\u2500 Field accessors (own fields) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${_}
 
-`);return`module ${e}::${t} { 
-    use sui::bcs::{to_bytes};
-    use std::ascii::{string, String, into_bytes};
-    use dubhe::table_id;
-    use dubhe::dapp_service::{Self, DappHub};
-    use dubhe::dapp_system;
-    use ${e}::dapp_key;
-    use ${e}::dapp_key::DappKey;
-${i.length>0?i.map(a=>`    use ${e}::${a.module};
-    use ${e}::${a.module}::{${a.type}};`).join(`
-`):""}
+    // \u2500\u2500\u2500 Bag accessors for accepted resources \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${y.join(`
+`)}
 
-    const TABLE_NAME: vector<u8> = b"${t}";
-    const OFFCHAIN: bool = ${l};
+    // \u2500\u2500\u2500 acceptsFrom: cross-storage transfer functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${b.join(`
+`)}
 
-    public struct ${H(t)} has copy, drop, store {
-${b}
+    // \u2500\u2500\u2500 Lifecycle entry functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    public(package) fun create_${r}(
+        dapp_storage: &mut DappStorage,
+        entity_id:    vector<u8>,
+        ctx:          &mut TxContext,
+    ) {
+${p}
+        dubhe::dapp_system::create_and_share_typed_object<DappKey, ${d}>(
+            dapp_key::new(), dapp_storage, TYPE_TAG, entity_id, ctx
+        );
     }
 
-    public fun new(${f}): ${H(t)} {
-        ${H(t)} {
-${m}
-        }
+    public(package) fun destroy_${r}(
+        dapp_storage: &mut DappStorage,
+        storage:      ${c},
+        _ctx:         &TxContext,
+    ) {
+        dubhe::dapp_system::destroy_typed_object<DappKey, ${d}>(
+            dapp_key::new(), dapp_storage, storage
+        );
     }
+}
+`;await E(f,ct.join(t,`${r}.move`),"formatAndWriteMove")}}import $t from"node:path";function _t(e){return e.split("_").map(t=>/^\d+$/.test(t)?t:t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}async function ze(e,t){if(!e.permits||Object.keys(e.permits).length===0)return;console.log(`
+\u{1F4E6} Starting Scene Permit Generation...`);let s=e.name;for(let n of Object.keys(e.permits)){console.log(`     \u2514\u2500 ${n}`);let r=_t(n),i=`b"${n}"`,d=`dubhe::dapp_service::ScenePermit<${r}>`,l=`module ${s}::${n} {
+    use dubhe::dapp_service::{Self, DappStorage};
+    use ${s}::dapp_key;
+    use ${s}::dapp_key::DappKey;
 
-${p}
+    const PERMIT_TYPE: vector<u8> = ${i};
 
-${A}
+    #[error]
+    const EPermitNotExpiredYet: vector<u8> = b"Scene permit is still active";
 
-${g}
-}`}function M(e){return["address","bool","u8","u32","u64","u128","u256","string","String","vector<address>","vector<bool>","vector<u8>","vector<vector<u8>>","vector<u32>","vector<u64>","vector<u128>","vector<u256>","vector<String>"].includes(e)}function He(e,t,s,n,c=!0,l=[],S="Onchain",D=!1){let o=Object.entries(s).filter(([r])=>!n.includes(r)).reduce((r,[_,d])=>({...r,[_]:d}),{}),$=Object.keys(o),v=Object.keys(s).every(r=>n.includes(r)),C=$.length===1,O=S==="Offchain",i=n.length>0?n.map(r=>`${r}: ${s[r]}`).join(", "):"",g=n.length>0?`let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);
-        ${n.map(r=>`key_tuple.push_back(to_bytes(&${r}));`).join(`
-        `)}`:`let mut key_tuple = vector::empty();
-        key_tuple.push_back(TABLE_NAME);`,b=D?"":"resource_account: String",f=D?"dapp_key::package_id().to_ascii_string()":"resource_account",m=b&&i?", ":"",p=O?"":`    public fun has(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}): bool {
-        ${g}
-        ${k(e)}::has_record<DappKey>(dapp_hub, ${f}, key_tuple)
+    /// Phantom type that distinguishes this permit from others at compile time.
+    public struct ${r} has copy, drop {}
+
+    public fun meta(permit: &${d}): &dubhe::dapp_service::PermitMetadata {
+        dapp_service::scene_permit_meta(permit)
     }
 
-    public fun ensure_has(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}) {
-        ${g}
-        ${k(e)}::ensure_has_record<DappKey>(dapp_hub, ${f}, key_tuple)
+    public fun is_active(permit: &${d}, now_ms: u64): bool {
+        dapp_service::is_scene_active(dapp_service::scene_permit_meta(permit), now_ms)
     }
 
-    public fun ensure_has_not(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}) {
-        ${g}
-        ${k(e)}::ensure_has_not_record<DappKey>(dapp_hub, ${f}, key_tuple)
+    public fun is_participant(permit: &${d}, addr: address): bool {
+        dubhe::dapp_system::is_scene_permit_participant<${r}>(permit, addr)
     }
-  `,A=O?"":`    public(package) fun delete(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}) {
-        ${g}
-        ${k(e)}::delete_record<DappKey>(dapp_hub, dapp_key::new(), key_tuple, ${f});
-    }`,a=!C&&!O?$.map(r=>{let _=$.indexOf(r),d=s[r],F=!M(d),E=F?l.find(he=>he.type===d):null;return`    public fun get_${r}(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}): ${d==="string"||d==="String"?"String":d==="vector<String>"?"vector<String>":d} {
-        ${g}
-        let value = ${k(e)}::get_field<DappKey>(dapp_hub, ${f}, key_tuple, ${_});
-        let mut bsc_type = sui::bcs::new(value);
-        ${d==="string"||d==="String"?`let ${r} = dubhe::bcs::peel_string(&mut bsc_type);`:d==="vector<String>"?`let ${r} = dubhe::bcs::peel_vec_string(&mut bsc_type);`:F?`let ${r} = ${e}::${E?.module}::decode(&mut bsc_type);`:`let ${r} = sui::bcs::peel_${W(d)}(&mut bsc_type);`}
-        ${r}
+
+    public(package) fun new_${n}(
+        dapp_storage:     &DappStorage,
+        participants:     vector<address>,
+        expires_at:       std::option::Option<u64>,
+        max_participants: std::option::Option<u64>,
+        ctx:              &mut TxContext,
+    ): ${d} {
+        dubhe::dapp_system::new_scene_permit<DappKey, ${r}>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, participants, expires_at, max_participants, ctx
+        )
     }
 
-    public(package) fun set_${r}(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, ${r}: ${d==="string"||d==="String"?"String":d==="vector<String>"?"vector<String>":d}) {
-        ${g}
-        let value = ${d==="string"||d==="String"?`to_bytes(&into_bytes(${r}))`:d==="vector<String>"?`to_bytes(&${r})`:F?`${e}::${E?.module}::encode(${r})`:`to_bytes(&${r})`};
-        ${k(e)}::set_field(dapp_hub, dapp_key::new(), key_tuple, ${_}, value, ${f});
-    }`}).join(`
+    public(package) fun new_${n}_with_invitations(
+        dapp_storage:      &DappStorage,
+        invitees:          vector<address>,
+        invites_expire_at: std::option::Option<u64>,
+        scene_expires_at:  std::option::Option<u64>,
+        max_participants:  std::option::Option<u64>,
+        ctx:               &mut TxContext,
+    ): ${d} {
+        dubhe::dapp_system::new_scene_permit_with_invitations<DappKey, ${r}>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, invitees, invites_expire_at, scene_expires_at, max_participants, ctx
+        )
+    }
 
-`):"",w=v?`    public(package) fun set(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = vector::empty();
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`:C?O?`    public(package) fun set(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, value: ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = encode(value);
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`:`    public fun get(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}): ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]} {
-        ${g}
-        let value = ${k(e)}::get_field<DappKey>(dapp_hub, ${f}, key_tuple, 0);
-        let mut bsc_type = sui::bcs::new(value);
-        ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"let value = dubhe::bcs::peel_string(&mut bsc_type);":Object.values(o)[0]==="vector<String>"?"let value = dubhe::bcs::peel_vec_string(&mut bsc_type);":M(Object.values(o)[0])?`let value = sui::bcs::peel_${W(Object.values(o)[0])}(&mut bsc_type);`:`let value = ${e}::${l.find(r=>r.type===Object.values(o)[0])?.module}::decode(&mut bsc_type);`}
-        value
+    public(package) fun share_${n}(permit: ${d}) {
+        dubhe::dapp_system::share_scene_permit<DappKey, ${r}>(
+            dapp_key::new(), permit
+        );
     }
 
-    public(package) fun set(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, value: ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = encode(value);
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`:O?`    public(package) fun set(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, ${$.map(r=>`${r}: ${s[r]==="string"||s[r]==="String"?"String":s[r]}`).join(", ")}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = encode(${$.join(", ")});
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`:`    public fun get(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}): (${Object.values(o).map(r=>r==="string"||r==="String"?"String":r).join(", ")}) {
-        ${g}
-        let value_tuple = ${k(e)}::get_record<DappKey>(dapp_hub, ${f}, key_tuple);
-        let mut bsc_type = sui::bcs::new(value_tuple);
-        ${$.map(r=>{let _=s[r],d=!M(_),F=d?l.find(E=>E.type===_):null;return`let ${r} = ${_==="string"||_==="String"?"dubhe::bcs::peel_string(&mut bsc_type)":_==="vector<String>"?"dubhe::bcs::peel_vec_string(&mut bsc_type)":d?`${e}::${F?.module}::decode(&mut bsc_type)`:`sui::bcs::peel_${W(_)}(&mut bsc_type)`};`}).join(`
-        `)}
-        (${$.join(", ")})
+    public(package) fun create_${n}(
+        dapp_storage:     &DappStorage,
+        participants:     vector<address>,
+        expires_at:       std::option::Option<u64>,
+        max_participants: std::option::Option<u64>,
+        ctx:              &mut TxContext,
+    ) {
+        dubhe::dapp_system::create_and_share_scene_permit<DappKey, ${r}>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, participants, expires_at, max_participants, ctx
+        );
     }
 
-    public(package) fun set(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, ${$.map(r=>`${r}: ${s[r]==="string"||s[r]==="String"?"String":s[r]}`).join(", ")}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = encode(${$.join(", ")});
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`,B=c?O?`    public(package) fun set_struct(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, ${t}: ${H(t)}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = encode_struct(${t});
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`:`    public fun get_struct(dapp_hub: &DappHub${b||i?", ":""}${b}${m}${i}): ${H(t)} {
-        ${g}
-        let value_tuple = ${k(e)}::get_record<DappKey>(dapp_hub, ${f}, key_tuple);
-        decode(value_tuple)
+    public(package) fun create_${n}_with_invitations(
+        dapp_storage:      &DappStorage,
+        invitees:          vector<address>,
+        invites_expire_at: std::option::Option<u64>,
+        scene_expires_at:  std::option::Option<u64>,
+        max_participants:  std::option::Option<u64>,
+        ctx:               &mut TxContext,
+    ) {
+        dubhe::dapp_system::create_and_share_scene_permit_with_invitations<DappKey, ${r}>(
+            dapp_key::new(), dapp_storage, PERMIT_TYPE, invitees, invites_expire_at, scene_expires_at, max_participants, ctx
+        );
     }
 
-    public(package) fun set_struct(dapp_hub: &mut DappHub${b||i?", ":""}${b}${m}${i}, ${t}: ${H(t)}, ctx: &mut TxContext) {
-        ${g}
-        let value_tuple = encode_struct(${t});
-        ${k(e)}::set_record(dapp_hub, dapp_key::new(), key_tuple, value_tuple, ${f}, OFFCHAIN, ctx);
-    }`:"",u=C?`    public fun encode(value: ${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"String":Object.values(o)[0]}): vector<vector<u8>> {
-        let mut value_tuple = vector::empty();
-        value_tuple.push_back(${Object.values(o)[0]==="string"||Object.values(o)[0]==="String"?"to_bytes(&into_bytes(value))":Object.values(o)[0]==="vector<String>"||M(Object.values(o)[0])?"to_bytes(&value)":`${e}::${l.find(r=>r.type===Object.values(o)[0])?.module}::encode(value)`});
-        value_tuple
-    }`:c?O?`    public fun encode(${$.map(r=>`${r}: ${s[r]==="string"||s[r]==="String"?"String":s[r]}`).join(", ")}): vector<vector<u8>> {
-        let mut value_tuple = vector::empty();
-        ${$.map(r=>{let _=s[r],d=!M(_),F=d?l.find(E=>E.type===_):null;return`value_tuple.push_back(${_==="string"||_==="String"?`to_bytes(&into_bytes(${r}))`:_==="vector<String>"?`to_bytes(&${r})`:d?`${e}::${F?.module}::encode(${r})`:`to_bytes(&${r})`});`}).join(`
-        `)}
-        value_tuple
+    public(package) fun accept_${n}(
+        permit:       &mut ${d},
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::accept_scene_permit_invitation<DappKey, ${r}>(
+            dapp_key::new(), permit, user_storage, ctx
+        );
     }
 
-    public fun encode_struct(${t}: ${H(t)}): vector<vector<u8>> {
-        encode(${$.map(r=>`${t}.${r}`).join(", ")})
-    }`:`    public fun encode(${$.map(r=>`${r}: ${s[r]==="string"||s[r]==="String"?"String":s[r]}`).join(", ")}): vector<vector<u8>> {
-        let mut value_tuple = vector::empty();
-        ${$.map(r=>{let _=s[r],d=!M(_),F=d?l.find(E=>E.type===_):null;return`value_tuple.push_back(${_==="string"||_==="String"?`to_bytes(&into_bytes(${r}))`:_==="vector<String>"?`to_bytes(&${r})`:d?`${e}::${F?.module}::encode(${r})`:`to_bytes(&${r})`});`}).join(`
-        `)}
-        value_tuple
+    public(package) fun join_${n}(
+        permit:       &mut ${d},
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::join_scene_permit<DappKey, ${r}>(dapp_key::new(), permit, user_storage, ctx);
     }
 
-    public fun encode_struct(${t}: ${H(t)}): vector<vector<u8>> {
-        encode(${$.map(r=>`${t}.${r}`).join(", ")})
+    public(package) fun leave_${n}(
+        permit:       &mut ${d},
+        user_storage: &dubhe::dapp_service::UserStorage,
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::leave_scene_permit<DappKey, ${r}>(dapp_key::new(), permit, user_storage, ctx);
     }
 
-    public fun decode(data: vector<u8>): ${H(t)} {
-        let mut bsc_type = sui::bcs::new(data);
-        ${$.map(r=>{let _=s[r],d=!M(_),F=d?l.find(E=>E.type===_):null;return`let ${r} = ${_==="string"||_==="String"?"string(sui::bcs::peel_vec_u8(&mut bsc_type))":_==="vector<String>"?"dubhe::bcs::peel_vec_string(&mut bsc_type)":d?`${e}::${F?.module}::decode(&mut bsc_type)`:`sui::bcs::peel_${W(_)}(&mut bsc_type)`};`}).join(`
-        `)}
-        ${H(t)} {
-            ${$.map(r=>`${r},`).join(`
-            `)}
-        }
-    }`:"";return[p,A,a,w,B,u].filter(r=>r.trim().length>0).join(`
+    public(package) fun expire_${n}(
+        permit: ${d},
+        ctx:    &TxContext,
+    ) {
+        assert!(
+            !dapp_service::is_scene_active(dapp_service::scene_permit_meta(&permit), ctx.epoch_timestamp_ms()),
+            EPermitNotExpiredYet
+        );
+        dubhe::dapp_system::destroy_scene_permit<DappKey, ${r}>(
+            dapp_key::new(), permit
+        );
+    }
+}
+`;await E(l,$t.join(t,`${n}.move`),"formatAndWriteMove")}}import mt from"node:path";function G(e){return e.split("_").map(t=>/^\d+$/.test(t)?t:t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}function bt(e){return e==="string"||e==="String"?"String":e}function N(e){return`dubhe::dapp_service::SceneStorage<${e}>`}function Z(e,t){if(t.authorization.kind==="permit")return`${e.name}::${t.authorization.permit}::${G(t.authorization.permit)}`}function Q(e,t){if(t.authorization.kind==="permit")return`dubhe::dapp_service::ScenePermit<${Z(e,t)}>`}function ft(e,t,s){let n=G(t),r=N(n),i=Z(e,s),d=Q(e,s),l=[];for(let[u,_]of Object.entries(s.fields)){let g=bt(_);s.authorization.kind==="permit"&&i&&d?l.push(`
+    public fun get_${u}(storage: &${r}): ${g} {
+        dubhe::dapp_system::get_scene_field<${n}, ${g}>(storage, b"${u}")
+    }
+
+    public(package) fun set_${u}(
+        permit:       &${d},
+        storage:      &mut ${r},
+        user_storage: &dubhe::dapp_service::UserStorage,
+        value:        ${g},
+        ctx:          &TxContext,
+    ) {
+        dubhe::dapp_system::set_scene_field<DappKey, ${i}, ${n}, ${g}>(
+            dapp_key::new(), permit, storage, user_storage, b"${u}", value, ctx
+        );
+    }
+
+    public(package) fun remove_${u}_system_maintenance(storage: &mut ${r}): ${g} {
+        dubhe::dapp_system::remove_scene_field_system_maintenance<DappKey, ${n}, ${g}>(
+            dapp_key::new(), storage, b"${u}"
+        )
+    }`):l.push(`
+    public fun get_${u}(storage: &${r}): ${g} {
+        dubhe::dapp_system::get_scene_field<${n}, ${g}>(storage, b"${u}")
+    }
+
+    public(package) fun set_${u}(storage: &mut ${r}, value: ${g}) {
+        dubhe::dapp_system::set_scene_field_system<DappKey, ${n}, ${g}>(
+            dapp_key::new(), storage, b"${u}", value
+        );
+    }
+
+    public(package) fun remove_${u}(storage: &mut ${r}): ${g} {
+        dubhe::dapp_system::remove_scene_field_system_maintenance<DappKey, ${n}, ${g}>(
+            dapp_key::new(), storage, b"${u}"
+        )
+    }`)}return l.join(`
+`)}function se(e,t){let s=Q(e,t);return t.authorization.kind!=="permit"||!s?"":`        permit:  &${s},
+`}function re(e){return e.authorization.kind!=="permit"?"":`        user_storage: &dubhe::dapp_service::UserStorage,
+`}function ne(e){return e.authorization.kind==="permit"?`        ctx:     &TxContext,
+`:""}function $e(e,t,s,n,r,i){let d=Z(e,t);return t.authorization.kind==="permit"&&d?`dubhe::dapp_system::set_scene_field<DappKey, ${d}, ${s}, ${n}>(
+            dapp_key::new(), permit, storage, user_storage, ${r}, ${i}, ctx
+        );`:`dubhe::dapp_system::set_scene_field_system<DappKey, ${s}, ${n}>(
+            dapp_key::new(), storage, ${r}, ${i}
+        );`}function yt(e,t,s,n,r){let i=Z(e,t);return t.authorization.kind==="permit"&&i?`dubhe::dapp_system::remove_scene_field<DappKey, ${i}, ${s}, ${n}>(
+            dapp_key::new(), permit, storage, user_storage, ${r}, ctx
+        )`:`dubhe::dapp_system::remove_scene_field_system_maintenance<DappKey, ${s}, ${n}>(
+            dapp_key::new(), storage, ${r}
+        )`}function ht(e,t,s,n){let r=G(t),i=N(r);return`
+    public fun get_${n}(storage: &${i}): u64 {
+        if (dubhe::dapp_system::has_scene_field<${r}, u64>(storage, b"${n}")) {
+            dubhe::dapp_system::get_scene_field<${r}, u64>(storage, b"${n}")
+        } else { 0 }
+    }
+
+    public(package) fun add_${n}(
+${se(e,s)}        storage: &mut ${i},
+${re(s)}        amount:  u64,
+${ne(s)}    ) {
+        let current = get_${n}(storage);
+        ${$e(e,s,r,"u64",`b"${n}"`,"current + amount")}
+    }
 
-`)}function H(e){return e.split("_").map((t,s)=>/^\d+$/.test(t)?t:t.charAt(0).toUpperCase()+t.slice(1).toLowerCase()).join("")}function W(e){if(e.startsWith("vector<")){let t=e.slice(7,-1);return t==="vector<u8>"?"vec_vec_u8":t==="String"?"vec_string":`vec_${W(t)}`}switch(e){case"u8":return"u8";case"u16":return"u16";case"u32":return"u32";case"u64":return"u64";case"u128":return"u128";case"u256":return"u256";case"bool":return"bool";case"address":return"address";case"String":return"string";default:return e}}import I from"node:path";async function Rt(e,t,s){console.log(`
-\u{1F680} Starting Schema Generation Process...`),console.log("\u{1F4CB} Project Configuration:"),console.log(`     \u2514\u2500 Name: ${t.name}`),console.log(`     \u2514\u2500 Description: ${t.description||"No description provided"}`),console.log(`     \u2514\u2500 Network: ${s||"testnet"}`),console.log(e);let n=I.join(e,"src",t.name);K(`${n}`)&&J(`${n}/sources/codegen`),K(`${n}/Move.toml`)||await ne(t,e);let c=I.join(n,"sources","codegen","genesis.move");K(c)||await ge(t,c);let l=I.join(n,"sources","codegen","init_test.move");K(l)||await _e(t,l);let S=I.join(n,"sources","codegen","dapp_key.move");K(S)||await oe(t,S);let D=I.join(n,"sources","scripts","deploy_hook.move");K(D)||await ue(t,D);let o=I.join(n,"sources","codegen","components");K(o)?await Z(t,o):await Z(t,o);let $=I.join(n,"sources","codegen","resources");K($)?await q(t,$):await q(t,$);let v=I.join(n,"sources","codegen","enums");K(v)||await ye(t,v),t.errors&&await le(t.name,t.errors,e),await ae(t,e),await ie(t,e),console.log(`
-\u2705  Schema Generation Process Complete!
-`)}var Ee=e=>{let t=Object.keys(e.components||{}),s=Object.keys(e.resources||{}),n=t.filter(c=>s.includes(c));if(n.length>0)throw new Error(`Duplicate keys found between components and resources: ${n.join(", ")}`)},Gt=e=>(Ee(e),e);import{findUp as je}from"find-up";import Q from"path";import Me from"esbuild";var V=class extends Error{name="NotInsideProjectError";message="You are not inside a Dubhe project"};import{rmSync as Ke}from"fs";import{pathToFileURL as Te}from"url";import Ie from"os";var Le=["dubhe.config.js","dubhe.config.mjs","dubhe.config.ts","dubhe.config.mts"],X="dubhe.config.example.mjs";async function es(e){e=await fe(e);try{return await Me.build({entryPoints:[e],format:"esm",outfile:X,platform:"node",bundle:!0,packages:"external"}),e=await fe(X,!0),(await import(e+`?update=${Date.now()}`)).dubheConfig}finally{Ke(X,{force:!0})}}async function fe(e,t){return e===void 0?e=await We():Q.isAbsolute(e)||(e=Q.join(process.cwd(),e),e=Q.normalize(e)),t&&Ie.platform()==="win32"?Te(e).href:e}async function We(){let e=await je(Le);if(e===void 0)throw new V;return e}var z=e=>{if(typeof e!="object"||e===null)return e;let t={};for(let s in e)if(e.hasOwnProperty(s)){let n=e[s];typeof n=="object"&&n!==null?Array.isArray(n)?t[s]=me(n):n.hasOwnProperty("variant")?t[s]={[n.variant]:{}}:n.hasOwnProperty("fields")?t[s]=z(n.fields):t[s]=z(n):t[s]=n}return t},me=e=>{let t=[];return e.forEach(s=>{typeof s=="object"&&s!==null?Array.isArray(s)?t.push(me(s)):s.hasOwnProperty("variant")?t.push({[s.variant]:{}}):s.hasOwnProperty("fields")?t.push(z(s.fields)):t.push(z(s)):t.push(s)}),t};var Be=(s=>(s.Event="event",s.Schema="schema",s))(Be||{});export{Be as SubscriptionKind,Gt as defineConfig,h as formatAndWriteMove,Ne as formatAndWriteTypescript,Ue as formatMove,N as formatTypescript,es as loadConfig,z as parseData,tt as posixPath,fe as resolveConfigPath,Rt as schemaGen};
+    public(package) fun sub_${n}(
+${se(e,s)}        storage: &mut ${i},
+${re(s)}        amount:  u64,
+${ne(s)}    ) {
+        let current = get_${n}(storage);
+        assert!(current >= amount, EInsufficientAmount);
+        ${$e(e,s,r,"u64",`b"${n}"`,"current - amount")}
+    }`}function vt(e,t,s,n,r){let i=G(t),d=N(i);return`
+    public fun has_${n}(storage: &${d}, ${r}: u64): bool {
+        let key = sui::bcs::to_bytes(&${r});
+        dubhe::dapp_system::has_scene_field<${i}, vector<u8>>(storage, key)
+    }
+
+    public fun get_${n}_data(storage: &${d}, ${r}: u64): vector<u8> {
+        let key = sui::bcs::to_bytes(&${r});
+        dubhe::dapp_system::get_scene_field<${i}, vector<u8>>(storage, key)
+    }
+
+    public(package) fun set_${n}_data(
+${se(e,s)}        storage: &mut ${d},
+${re(s)}        ${r}: u64,
+        data:    vector<u8>,
+${ne(s)}    ) {
+        let key = sui::bcs::to_bytes(&${r});
+        assert!(!dubhe::dapp_system::has_scene_field<${i}, vector<u8>>(storage, key), EDuplicateItemId);
+        ${$e(e,s,i,"vector<u8>","key","data")}
+    }
+
+    public(package) fun remove_${n}_data(
+${se(e,s)}        storage: &mut ${d},
+${re(s)}        ${r}: u64,
+${ne(s)}    ): vector<u8> {
+        let key = sui::bcs::to_bytes(&${r});
+        assert!(dubhe::dapp_system::has_scene_field<${i}, vector<u8>>(storage, key), EFieldNotFound);
+        ${yt(e,s,i,"vector<u8>","key")}
+    }`}function kt(e,t,s,n,r,i){let d=i.resources??{},l=i.objects??{},u=i.scenes??{},_=G(t),g=N(_),y=[],o=[],b=Q(i,s),p=s.authorization.kind==="permit"&&b?`        dest_permit: &${b},
+`:"",h=s.authorization.kind==="permit"?"dest_permit, ":"",a=s.authorization.kind==="permit"?", ctx":"";for(let $ of r){let x=l[$]??u[$];if(!x)continue;let k=x.accepts??[],T=G($);y.push(`    use ${e}::${$};`);let w=!!u[$],F=`${e}::${$}::${T}`,O=w?`dubhe::dapp_service::SceneStorage<${F}>`:`dubhe::dapp_service::ObjectStorage<${F}>`,A=w?x:void 0,D=A?Q(i,A):void 0,v=A?.authorization.kind==="permit"&&!!D,K=v?`        source_permit: &${D},
+`:"",P=v?"source_permit, ":"",c=v?"user_storage, ":"",f=v?", ctx":"",S=s.authorization.kind==="permit",j=S?"user_storage, ":"",M=v||S?`        user_storage: &dubhe::dapp_service::UserStorage,
+`:"",ee=v||S?`        ctx:         &TxContext,
+`:"",m=k.filter(C=>n.includes(C));for(let C of m){let W=d[C];if(!W||typeof W=="string")continue;let Y=W;if(!Y.fungible&&Y.keys?.length){let ae=Y.keys[0];o.push(`
+    public(package) fun transfer_${$}_to_${t}_${C}(
+${K}${p}        from:        &mut ${O},
+        to:          &mut ${g},
+${M}        ${ae}: u64,
+${ee}    ) {
+        let data = ${$}::remove_${C}_data(${P}from, ${c}${ae}${f});
+        set_${C}_data(${h}to, ${j}${ae}, data${a});
+    }`)}else o.push(`
+    public(package) fun transfer_${$}_to_${t}_${C}(
+${K}${p}        from:   &mut ${O},
+        to:     &mut ${g},
+${M}        amount: u64,
+${ee}    ) {
+        ${$}::sub_${C}(${P}from, ${c}amount${f});
+        add_${C}(${h}to, ${j}amount${a});
+    }`)}}return{imports:y,functions:o}}async function He(e,t){if(!e.scenes||Object.keys(e.scenes).length===0)return;console.log(`
+\u{1F4E6} Starting Scene Storage Generation...`);let s=e.name,n=e.resources??{};for(let[r,i]of Object.entries(e.scenes)){console.log(`     \u2514\u2500 ${r}`);let d=G(r),l=`b"${r}"`,u=N(d),_=ft(e,r,i),g=i.accepts??[],y=[];for(let D of g){let v=n[D];if(!v||typeof v=="string")continue;let K=v;!K.fungible&&K.keys?.length?y.push(vt(e,r,i,D,K.keys[0])):y.push(ht(e,r,i,D))}let{imports:o,functions:b}=kt(s,r,i,g,i.acceptsFrom??[],e),a=Object.values(i.fields).some(D=>D==="string"||D==="String"||D==="vector<String>")?`
+    use std::ascii::String;`:"",$=g.some(D=>{let v=n[D];return!v||typeof v=="string"?!1:!!v.keys?.length&&!v.fungible}),x=g.some(D=>{let v=n[D];return!v||typeof v=="string"?!1:!!v.fungible}),k=[$?`    #[error]
+    const EFieldNotFound: vector<u8> = b"Field not found";`:"",x?`    #[error]
+    const EInsufficientAmount: vector<u8> = b"Insufficient amount";`:"",$?`    #[error]
+    const EDuplicateItemId: vector<u8> = b"Duplicate item id";`:""].filter(Boolean).join(`
+`),T=k.length>0?`
+    // \u2500\u2500\u2500 Error constants \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${k}
+`:"",w=o.length>0?`
+`+o.join(`
+`):"",F=Q(e,i),O=i.authorization.kind==="permit"&&F?`
+    public(package) fun new_${r}_with_permit(
+        dapp_storage: &DappStorage,
+        permit:       &${F},
+        ctx:          &mut TxContext,
+    ): ${u} {
+        dubhe::dapp_system::new_typed_scene_with_permit<DappKey, ${Z(e,i)}, ${d}>(
+            dapp_key::new(), dapp_storage, permit, SCENE_TYPE, ctx
+        )
+    }
+
+    public(package) fun create_${r}_with_permit(
+        dapp_storage: &DappStorage,
+        permit:       &${F},
+        ctx:          &mut TxContext,
+    ) {
+        dubhe::dapp_system::create_and_share_typed_scene_with_permit<DappKey, ${Z(e,i)}, ${d}>(
+            dapp_key::new(), dapp_storage, permit, SCENE_TYPE, ctx
+        );
+    }`:`
+    public(package) fun new_${r}_system(
+        dapp_storage: &DappStorage,
+        ctx:          &mut TxContext,
+    ): ${u} {
+        dubhe::dapp_system::new_typed_scene_system<DappKey, ${d}>(
+            dapp_key::new(), dapp_storage, SCENE_TYPE, ctx
+        )
+    }
+
+    public(package) fun create_${r}_system(
+        dapp_storage: &DappStorage,
+        ctx:          &mut TxContext,
+    ) {
+        dubhe::dapp_system::create_and_share_typed_scene_system<DappKey, ${d}>(
+            dapp_key::new(), dapp_storage, SCENE_TYPE, ctx
+        );
+    }`,A=`module ${s}::${r} {
+    use dubhe::dapp_service::DappStorage;
+    use ${s}::dapp_key;
+    use ${s}::dapp_key::DappKey;${a}${w}
+${T}
+    const SCENE_TYPE: vector<u8> = ${l};
+
+    /// Phantom type that distinguishes this scene storage at compile time.
+    public struct ${d} has copy, drop {}
+
+    // \u2500\u2500\u2500 Field accessors (own fields) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${_}
+
+    // \u2500\u2500\u2500 Bag accessors for accepted resources \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${y.join(`
+`)}
+
+    // \u2500\u2500\u2500 acceptsFrom: cross-storage transfer functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${b.join(`
+`)}
+
+    // \u2500\u2500\u2500 SceneStorage lifecycle wrappers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+${O}
+
+    public(package) fun share_${r}(storage: ${u}) {
+        dubhe::dapp_system::share_scene_storage<DappKey, ${d}>(
+            dapp_key::new(), storage
+        );
+    }
+
+    public(package) fun destroy_${r}(storage: ${u}) {
+        dubhe::dapp_system::destroy_typed_scene<DappKey, ${d}>(
+            dapp_key::new(), storage
+        );
+    }
+}
+`;await E(A,mt.join(t,`${r}.move`),"formatAndWriteMove")}}async function We(e,t){if(e.name==="dubhe")return;let s=`module ${e.name}::user_storage_init {
+  use dubhe::dapp_service::{DappHub, DappStorage};
+  use dubhe::dapp_system;
+  use ${e.name}::dapp_key;
+  use ${e.name}::dapp_key::DappKey;
+  use ${e.name}::migrate;
+
+  /// Create a UserStorage for the transaction sender within this DApp.
+  /// Must be called once before the user can interact with any user-level resources.
+  /// Aborts if the DApp version does not match this package, the DApp is paused,
+  /// or the framework version has advanced.
+  #[allow(lint(public_entry))]
+  public entry fun init_user_storage(
+      dapp_hub: &DappHub,
+      dapp_storage: &mut DappStorage,
+      ctx: &mut TxContext,
+  ) {
+      dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+      dapp_system::create_user_storage(dapp_key::new(), dapp_hub, dapp_storage, ctx);
+  }
+}
+`;await E(s,t,"formatAndWriteMove")}import Ye from"chalk";import{existsSync as St,readFileSync as xt,writeFileSync as Ve}from"fs";import Ct from"node:path";function wt(e){if(typeof e=="string")return{value:e};let t={};for(let[s,n]of Object.entries(e.fields??{}))t[s]=n;return t}function Ge(e){let t={};for(let[s,n]of Object.entries(e.fields))t[s]=n;return t}function Dt(e){let t={};for(let[r,i]of Object.entries(e.resources??{}))t[r]=wt(i);let s={};for(let[r,i]of Object.entries(e.objects??{}))s[r]=Ge(i);let n={};for(let[r,i]of Object.entries(e.scenes??{}))n[r]=Ge(i);return{version:1,resources:t,objects:s,scenes:n}}function _e(e,t,s){for(let[n,r]of Object.entries(s)){let i=t[n];if(i)for(let[d,l]of Object.entries(i)){if(!(d in r))throw new Error(`[dubhe] Breaking change detected in ${e}.${n}:
+  Field "${d}" was removed.
+
+Resources, objects, and scenes are stored as raw bytes on-chain.
+Removing fields corrupts existing data. Use a new name (e.g. "${n}_v2") for breaking changes.`);if(r[d]!==l)throw new Error(`[dubhe] Breaking change detected in ${e}.${n}:
+  Field "${d}" type changed from "${l}" to "${r[d]}".
+
+Resources, objects, and scenes are stored as raw bytes on-chain.
+Changing field types corrupts existing data. Use a new name (e.g. "${n}_v2") for breaking changes.`)}}}function qe(e,t){let s=Ct.join(e,`${t.name}.lock.json`),n=Dt(t);if(St(s)){let r;try{r=JSON.parse(xt(s,"utf-8"))}catch{console.warn(Ye.yellow("[dubhe]")+` Could not parse ${Ye.bold(s)}, skipping break-check.`),Ve(s,JSON.stringify(n,null,2)+`
+`,"utf-8");return}_e("resources",r.resources??{},n.resources),_e("objects",r.objects??{},n.objects),_e("scenes",r.scenes??{},n.scenes)}Ve(s,JSON.stringify(n,null,2)+`
+`,"utf-8")}import U from"chalk";var oe=e=>console.warn(U.yellow("[dubhe codegen]")+U.yellow(" WARNING: ")+e);function Je(e){me(e,!1)}function me(e,t=!0){let s=e.resources??{},n=e.objects??{},r=e.permits??{},i=e.scenes??{},d=new Set(Object.keys(s)),l=new Set(Object.keys(n)),u=new Set(Object.keys(r)),_=new Set(Object.keys(i)),g=new Set;for(let o of d)(l.has(o)||u.has(o)||_.has(o))&&g.add(o);for(let o of l)(u.has(o)||_.has(o))&&g.add(o);for(let o of u)_.has(o)&&g.add(o);if(g.size>0)throw new Error(`Duplicate module names found across resources/objects/permits/scenes: ${[...g].sort().join(", ")}`);let y=new Set;for(let[o,b]of Object.entries(n)){for(let p of b.accepts??[]){y.add(p);let h=s[p];if(!h)throw new Error(`objects.${o}.accepts references '${p}' which is not defined in resources`);if(typeof h!="string"&&!h.transferable)throw new Error(`objects.${o}.accepts includes '${p}', but resources.${p} is missing transferable: true. Add transferable: true to resources.${p} to enable cross-storage transfers.`)}for(let p of b.acceptsFrom??[]){let h=!!n[p],a=!!i[p];if(!h&&!a)throw new Error(`objects.${o}.acceptsFrom references '${p}' which is not defined in objects or scenes`)}}for(let[o,b]of Object.entries(i)){if(!b.authorization)throw new Error(`scenes.${o} is missing authorization. Use { kind: 'system' } or { kind: 'permit', permit: '<permit_name>' }.`);if(b.authorization.kind==="permit"){if(!r[b.authorization.permit])throw new Error(`scenes.${o}.authorization references permit '${b.authorization.permit}', but permits.${b.authorization.permit} is not defined`)}else if(b.authorization.kind!=="system")throw new Error(`scenes.${o}.authorization.kind must be 'system' or 'permit'`);for(let p of b.accepts??[]){y.add(p);let h=s[p];if(!h)throw new Error(`scenes.${o}.accepts references '${p}' which is not defined in resources`);if(typeof h!="string"&&!h.transferable)throw new Error(`scenes.${o}.accepts includes '${p}', but resources.${p} is missing transferable: true. Add transferable: true to resources.${p} to enable cross-storage transfers.`)}for(let p of b.acceptsFrom??[]){let h=!!n[p],a=!!i[p];if(!h&&!a)throw new Error(`scenes.${o}.acceptsFrom references '${p}' which is not defined in objects or scenes`)}}for(let[o,b]of Object.entries(s)){if(typeof b=="string")continue;let p=b;if(p.offchain){if(p.listable)throw new Error(`resources.${o} has both offchain: true and listable: true. offchain resources emit events but store no on-chain state, so there is nothing to take out and place into a Listing.`);if(p.transferable)throw new Error(`resources.${o} has both offchain: true and transferable: true. offchain resources have no on-chain state to transfer between storages.`);if(p.reactive)throw new Error(`resources.${o} has both offchain: true and reactive: true. reactive writes target on-chain state, which offchain resources do not have.`);p.fungible&&t&&oe(`resources.${U.bold(o)} has both ${U.cyan("offchain: true")} and ${U.cyan("fungible: true")}. offchain fungible events are emitted only; no on-chain balance is maintained and no add/sub functions are generated. This is unusual \u2014 verify your intent.`)}if(p.reactive&&p.fungible&&t&&oe(`resources.${U.bold(o)} has both ${U.cyan("reactive: true")} and ${U.cyan("fungible: true")}. Fungible quantity changes (add/sub) do not suit reactive cross-user writes. Consider using a transfer function instead.`),p.global){if(p.reactive)throw new Error(`resources.${o} has both global: true and reactive: true. global resources live in DappStorage (shared), not in UserStorage. Reactive writes operate between two UserStorage objects and are incompatible with global resources.`);if(p.listable)throw new Error(`resources.${o} has both global: true and listable: true. global resources live in DappStorage and cannot be individually listed for sale. listable requires per-user ownership in UserStorage.`);if(p.transferable)throw new Error(`resources.${o} has both global: true and transferable: true. global resources live in DappStorage and are not owned by individual users. transferable requires per-user state in UserStorage or ObjectStorage.`)}p.fungible&&p.listable&&t&&oe(`resources.${U.bold(o)} has both ${U.cyan("fungible: true")} and ${U.cyan("listable: true")}. The generated ${U.green(`list_${o}`)} entry function will include an ${U.cyan("amount")} parameter for partial listings.`),p.transferable&&!y.has(o)&&t&&oe(`resources.${U.bold(o)} has ${U.cyan("transferable: true")} but is not referenced in any ${U.cyan("objects.accepts")} or ${U.cyan("scenes.accepts")}. The cross-layer transfer functions will not be generated.`)}}import L from"node:path";async function jt(e,t,s,n=1){console.log(`
+\u{1F680} Starting Code Generation Process...`),console.log("\u{1F4CB} Project Configuration:"),console.log(`     \u2514\u2500 Name: ${t.name}`),console.log(`     \u2514\u2500 Description: ${t.description||"No description provided"}`),console.log(`     \u2514\u2500 Network: ${s||"testnet"}`),console.log(`     \u2514\u2500 Settlement Mode: ${n===1?"USER_PAYS":"DAPP_SUBSIDIZES"}`),me(t),qe(e,t),console.log(e);let r=L.join(e,"src",t.name);q(`${r}`)&&pe(`${r}/sources/codegen`),q(`${r}/Move.toml`)||await Se(t,e);let i=L.join(r,"sources","codegen","genesis.move");q(i)||await Fe(t,i,n);let d=L.join(r,"sources","codegen","init_test.move");q(d)||await Oe(t,d);let l=L.join(r,"sources","codegen","dapp_key.move");q(l)||await De(t,l);let u=L.join(r,"sources","scripts","deploy_hook.move");q(u)||await Ce(t,u,n);let _=L.join(r,"sources","codegen","resources");await Le(t,_);let g=L.join(r,"sources","codegen","objects");await Be(t,g);let y=L.join(r,"sources","codegen","permits");await ze(t,y);let o=L.join(r,"sources","codegen","scenes");await He(t,o);let b=L.join(r,"sources","codegen","enums");q(b)||await Ie(t,b),t.errors&&await Ee(t.name,t.errors,e);let p=L.join(r,"sources","codegen","user_storage_init.move");await We(t,p),await Ae(t,e),await we(t,e),console.log(`
+\u2705  Code Generation Complete!
+`)}var er=jt;var rr=e=>(Je(e),e);import{findUp as Tt}from"find-up";import be from"path";import At from"esbuild";var ie=class extends Error{name="NotInsideProjectError";message="You are not inside a Dubhe project"};import{rmSync as Et}from"fs";import{pathToFileURL as Ot}from"url";import Ft from"os";var Kt=["dubhe.config.js","dubhe.config.mjs","dubhe.config.ts","dubhe.config.mts"],fe="dubhe.config.example.mjs";async function gr(e){e=await Ze(e);try{return await At.build({entryPoints:[e],format:"esm",outfile:fe,platform:"node",bundle:!0,packages:"external"}),e=await Ze(fe,!0),(await import(e+`?update=${Date.now()}`)).dubheConfig}finally{Et(fe,{force:!0})}}async function Ze(e,t){return e===void 0?e=await It():be.isAbsolute(e)||(e=be.join(process.cwd(),e),e=be.normalize(e)),t&&Ft.platform()==="win32"?Ot(e).href:e}async function It(){let e=await Tt(Kt);if(e===void 0)throw new ie;return e}var Ut=(s=>(s.Event="event",s.Schema="schema",s))(Ut||{});export{Ut as SubscriptionKind,qe as checkAndUpdateLock,jt as codegen,rr as defineConfig,E as formatAndWriteMove,Rt as formatMove,Be as generateObjects,He as generateScenes,gr as loadConfig,er as schemaGen};
 //# sourceMappingURL=index.js.map